DEV Community: Toul

Get Automate the Boring Stuff with GO (e-book PDF)

Toul — Sat, 16 Nov 2024 17:47:05 +0000

Hi Automate the Boring Stuff with GO series readers!

I've created a proper e-book version of of Automate the Boring Stuff with GO for you to download:

Automate the Boring Stuff with GO (e-book PDF)

It is especially helpful for when you don't have internet connectivity and want to follow along, so feel free to grab copy for any price you want.

Chapters 8,9,10, and 11

Toul — Mon, 29 Jan 2024 16:11:36 +0000

Hello aspiring Gophers, it has been some time since I've updated this project.

My apologies as I've gone through several major life changes, the largest of which involved moving my young family to NYC, an ongoing process that has taken much of my energy.
The good news is the project is complete from the code side, the bad news is that it isn't from the writing side, and rather than keep you waiting, I'm going to share the code with you!

So, for those of you who've made it this far Chapter 8– a Congratulations is in order "Well, done! You've made it farther than 80% of readers".

To support you and the rest of your journey, I'm providing the remainder of the code and links to the projects so that you can have a look, run the code, and have it for reference in your budding career as a GoLang enthusiast.

Chapter 8 - File Wrangling

Chapter 9 - Excelling with GO

This is probably the most useful code for those in Corporate.
Starting with Excel

Chapter 10 - PDF Hero

Chapter 11 - Web Scraping

It is important to know that it is possible to programmatically surf the web and download data. The first code pieces show doing it using only HTTP request methods, and 'automating a browser' shows how to do so as if you were opening a browser on your computer and visiting the site.
You'll need to do such things from time to time when Websites make it challenging to scrape data.

Wow! You've made it through all that code? Congratulations, again!

You may be thinking 'Now what'. I'd recommend trying to use a little bit of what you learned at work to automate things. You may be thinking 'How will I know what or when to automate' Well a wise dev mentor once told me "If you're doing it more than 3 times a week, then maybe that's something worth automating", does anything come to mind? If so then have a look through the book for some code inspiration or even for the most likely terms to Google.
Again, it has been a pleasure to support you on your journey so far, please do ask questions.

P.S.
If you want to get some opensource creds then maybe take a crack at writing for some of the remaining chapters, and make a Pull request on the GitHub repository.
It can be a way to get some dev cred for your resume if you're thinking about going into the field of programming or tech in general.

Sincerely,
Toul

Ch. 7 String Manipulation

Toul — Thu, 13 Apr 2023 16:10:20 +0000

In this chapter, I'm sharing the string manipulation cheatsheet in part I. to keep on hand for reference when working with strings, which you will be doing a lot of when it comes to automating day-to-day work. Then, you'll find a few useful projects to help flex your string manipulation learnings in part II.

Note: Here's the GitHub for the Project Section after the Cheat Sheet

I. String Manipulation cheatsheet
Print this out, tape it by your desk, or put it in your favorite three-ring binder for school. It contains almost every string manipulation with an expression as an example for when you're working.
String Literals

II. Projects

Regex E-Mail finder from clipboard

In this project, we'll use Regex to determine if a piece of text copied to our clipboard contains an e-mail. The pattern of finding an e-mail in a string of text is handy as you'll probably receive data where it will be useful to the group based on a common characteristic.

If you're interested in building a web application with sign-up / sign-in input fields based on e-mails, this can be useful for determining whether the input is of the correct form.

Note: There is a third-party package dependency in this project, but I trust you remember how to handle that requirement hint go mod init & go get

package main

import (
    "fmt"
    "regexp"
    "strings"
    "github.com/atotto/clipboard"
)

func main() {
    // create email regexp
    regMail, _ := regexp.Compile(`[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,6}`)

    // read os buffer
    // find email regexp
    text, _ := clipboard.ReadAll()
    var mailAddr []string
    // found e-mail
    if regMail.MatchString(text) {
        mailAddr = regMail.FindAllString(text, -1)
    }

    // Print found e-mails on the terminal
    if len(mailAddr) > 0 {
        clipboard.WriteAll(strings.Join(mailAddr, "\n"))
        fmt.Println("Copied to clipboard:")
        fmt.Println(strings.Join(mailAddr, "\n"))
    } else {
        fmt.Println("No email addresses found.")
    }
}

Regex Password Complexity Checker

Password complexity is an additional feature you will want to have for an application. This is because simple passwords are easier for cyber criminals to obtain/guess.

Hence, it is wise to enforce a password complexity of at least 11 characters with some capital letters and numbers thrown in. So, let's build a small program to check whether or not a given password passes the complexity requirement.

package main

import (
    "fmt"
    "os"
    "regexp"

    "flag"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Printf("Usage: %s -h\n", os.Args[0])
    } else {
        pass := flag.String("p", "", "get password")

        flag.Parse()

        regStr, _ := regexp.Compile(`([0-9a-zA-Z]){11,}`)

        if regStr.MatchString(*pass) {
            fmt.Println("Password ok")
        } else {
            fmt.Println("Bad password")
        }

        os.Exit(0)
    }
}

Running the program and passing in your possible password should result in either a Password OK or Bad Password response from the program:

t@m1 regexppass % go run main.go --p=23498aosethuaosthAT
Pass ok
t@m1 regexppass % go run main.go --p=2Aoeue             
Bad password
t@m1 regexppass % go run main.go --p=2AoeueEEEE
Bad password

Quiz Builder

Now, this project is the first in our queue at automating a mundane work task--your teacher friends will love you!
In this project, you'll build a quiz generator around the U.S. and its capitals. However, you will generally have the format of a quiz-building piece of software that can be changed to generate different sorts of quizzes. Maybe, you'll change it to do the capitals of your home country and its states.

package main

import (
    "math/rand"
    "os"
    "strconv"
    "strings"
    "time"
)

func main() {
    capitals := map[string]string{
        "Alabama":        "Montgomery",
        "Alaska":         "Juneau",
        "Arizona":        "Phoenix",
        "Arkansas":       "Little Rock",
        "California":     "Sacramento",
        "Colorado":       "Denver",
        "Connecticut":    "Hartford",
        "Delaware":       "Dover",
        "Florida":        "Tallahassee",
        "Georgia":        "Atlanta",
        "Hawaii":         "Honolulu",
        "Idaho":          "Boise",
        "Illinois":       "Springfield",
        "Indiana":        "Indianapolis",
        "Iowa":           "Des Moines",
        "Kansas":         "Topeka",
        "Kentucky":       "Frankfort",
        "Louisiana":      "Baton Rouge",
        "Maine":          "Augusta",
        "Maryland":       "Annapolis",
        "Massachusetts":  "Boston",
        "Michigan":       "Lansing",
        "Minnesota":      "Saint Paul",
        "Mississippi":    "Jackson",
        "Missouri":       "Jefferson City",
        "Montana":        "Helena",
        "Nebraska":       "Lincoln",
        "Nevada":         "Carson City",
        "New Hampshire":  "Concord",
        "New Jersey":     "Trenton",
        "New Mexico":     "Santa Fe",
        "New York":       "Albany",
        "North Carolina": "Raleigh",
        "North Dakota":   "Bismarck",
        "Ohio":           "Columbus",
        "Oklahoma":       "Oklahoma City",
        "Oregon":         "Salem",
        "Pennsylvania":   "Harrisburg",
        "Rhode Island":   "Providence",
        "South Carolina": "Columbia",
        "South Dakota":   "Pierre",
        "Tennessee":      "Nashville",
        "Texas":          "Austin",
        "Utah":           "Salt Lake City",
        "Vermont":        "Montpelier",
        "Virginia":       "Richmond",
        "Washington":     "Olympia",
        "West Virginia":  "Charleston",
        "Wisconsin":      "Madison",
        "Wyoming":        "Cheyenne",
    }

    var states, capitalsItems []string
    for y, x := range capitals {
        capitalsItems = append(capitalsItems, x)
        states = append(states, y)
    }

    for i := 0; i < 35; i++ {
        // сreate the quiz text file
        str1 := "quiz_" + strconv.Itoa(i+1) + ".txt"
        quizFile, err := os.Create(str1)
        check(err)
        defer quizFile.Close()
        // create the answer key to the quiz
        str2 := "answer_key_" + strconv.Itoa(i+1) + ".txt"
        answerKeyFile, err := os.Create(str2)
        check(err)
        defer answerKeyFile.Close()

        // Create portion for students to fill out
        quizFile.WriteString("Student Number:\n\nName:\n\nDate:\n\n")
        str3 := "Quiz " + strconv.Itoa(i+1)
        quizFile.WriteString(strings.Repeat(" ", 20) + str3)
        quizFile.WriteString("\n\n")

        rand.Seed(time.Now().UnixNano())
        // mix of the States
        shuffle(states)

        // Iterate through and build the question out 
        for j := 0; j < 50; j++ {
            correctAnswer := capitals[states[j]]
            wrongAnswers := make([]string, len(capitalsItems))
            copy(wrongAnswers, capitalsItems)

            // shuffle wrong answers
            answNoCorrect := make([]string, len(wrongAnswers)-1)
            for l := 0; l < len(wrongAnswers); l++ {
                if wrongAnswers[l] == correctAnswer {
                    copy(answNoCorrect, removeAtIndex(wrongAnswers, l))
                }
            }

            // create answer options A-D
            var answerOptions []string
            for l := 0; l < 3; l++ {
                answerOptions = append(answerOptions, answNoCorrect[l])
            }
            answerOptions = append(answerOptions, correctAnswer)
            shuffle(answerOptions)

            // create question
            str3 := strconv.Itoa(j+1) + " What is the Capital of " + states[j] + "?" + "\n"
            quizFile.WriteString(str3)
            strAbcd := "ABCD"
            for l := 0; l < 4; l++ {
                strAnsw := string(strAbcd[l]) + ". " + answerOptions[l] + "\n"
                quizFile.WriteString(strAnsw)
            }
            // make quiz and save it
            quizFile.WriteString("\n")

            // make answer key and save it
            strAnswerOk := ""
            for l := 0; l < len(answerOptions); l++ {
                if answerOptions[l] == correctAnswer {
                    strAnswerOk += string(strAbcd[l])
                }
            }
            strCorAnsw := strconv.Itoa(j+1) + ". " + strAnswerOk + "\n"
            answerKeyFile.WriteString(strCorAnsw)
        }
    }
}

// helper functions for making quiz building easier
func check(e error) {
    if e != nil {
        panic(e)
    }
}

func shuffle(a []string) {
    for i := range a {
        j := rand.Intn(i + 1)
        a[i], a[j] = a[j], a[i]
    }
}

func removeAtIndex(source []string, index int) []string {
    lastIndex := len(source) - 1
    source[index], source[lastIndex] = source[lastIndex], source[index]
    return source[:lastIndex]
}

There you have it, the foundation of all the string knowledge you'll use to work with string data in files, clipboards, or anywhere else.

Ch 6. Maps

Toul — Thu, 13 Apr 2023 16:05:22 +0000

Like in real life, a map is a way of containing data that defines something. Think of the map of New York City. It is a piece of paper that includes data about the city's layout– depending on the map type.
Maps are typically handy when you combine different data types because a slice will only permit one data type per-use.
We'll briefly cover Maps so the reader can be aware of them and see when they might be useful.

Syntax

A map uses the 'map' keyword and [type] followed again by 'type.'

package main

func main() {
  nyc := map[string]int{
      "population": 8000000,
      "size": 302,
  }
  htx := map[string]int{
    "population": 2000000,
    "size": 665,
  }
}

It says a map made of key-pair values of type string and int.
You can have any combination of types with maps, which is when you should consider using them over a slice.

Use case

Although the data is small above it is enough to let us access quick facts about each city with a fast lookup, with syntax similar to a slice.

package main

import "fmt"
func main() {
  nyc := map[string]int{
      "population": 8000000,
      "size": 302,
  }
  htx := map[string]int{
    "population": 2000000,
    "size": 665,
  }
  fmt.Println(htx["population"], nyc["population"])
}

The curious reader should take a look at Go Maps in Action by the GO dev team to get a better sense of when to use 'maps'.

Conclusion

It is enough to know a map and how it generally works. Now, let's move on to part II of automating the boring stuff with go, which contains much more fun practical examples.

Ch. 5 Slices

Toul — Thu, 13 Apr 2023 16:02:46 +0000

Slices in Golang are the same as dynamic arrays. An array is the first data structure you'll probably learn about in any book related to learning a programming language. Slices can contain any data type, including a slice itself, making arranging data into hierarchical structures simpler.
In this chapter, we'll go over the basics of Slices, and I'll teach you about some of the most useful methods available to slices.

The Slice Data Type

The slice type has an upper and lower bound separated by a colon but is not inclusive, meaning that the upper bound value isn't used.
For example

package main

import "fmt"

func main() {
    evens := [5]int{2, 4, 6, 8, 10 }
    var s []int = evens[1:4]
    fmt.Println(s)

}

will output
"4 6 8 "

Accessing values in a slice with Indexes

Like many other languages in GO, getting a single value from a slice is possible. Let's say instead of using evens[1:4], it had read evens[0] will only output "2".
Slice of Slices
Slices may contain any type, including other slices, which can be considered a grid when used. A familiar example for those not into math is Tic-tac-toe rather than the x,y coordinate plane.

package main

import (
    "fmt"
    "strings"
)

func main() {
    // Create a tic-tac-toe board.
    board := [][]string{
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
    }

    // The players take turns.
    board[0][0] = "X"
    board[2][2] = "O"
    board[1][2] = "X"
    board[1][0] = "O"
    board[0][2] = "X"

    for i := 0; i < len(board); i++ {
        fmt.Printf("%s\n", strings.Join(board[i], " "))
    }
}

Which will output,

X _ X
O _ X
_ _ O

Using empty slices

An empty-sized slice is helpful when you don't know how many elements will be in it, but you do plan on using it. So you'd declare it like this.

package main

import "fmt"

func main() {
    a := []int{}
    fmt.Println(a)

}

Which will output '[],' showing that it's an empty slice waiting to be filled.

Appending to a Slice

When working with slices, it is often necessary to add new elements to the slice, and the appropriate way of doing so in go is to use the 'append' method.

package main

import "fmt"

func main() {
    var s []int
    printSlice(s)

    // append works on nil slices.
    s = append(s, 0)
    printSlice(s)

    // The slice grows as needed.
    s = append(s, 1)
    printSlice(s)

    // We can add more than one element at a time.
    s = append(s, 2, 3, 4)
    printSlice(s)
}

func printSlice(s []int) {
    fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

Getting a Slice's length with len() func.

Similarly, to add elements to a slice, it is often essential to know how many features are inside a slice.

package main

import "fmt"

func main() {
    s := []int{2, 3, 5, 7, 11, 13}
    fmt.Println(len(s))


}

Changing Values in a Slice with Indexes

Sometimes, you'll also want to update a specific value in the Slice without altering others.

package main

import "fmt"

func main() {
    s := []int{2, 3, 5, 7, 11, 13}
    s[1] = 234234
    fmt.Println(s)


}

Which will output[2 234234 5 7 11 13]

Using Slices

Okay, now that the basics of slices are down, let's see how and why we'd probably use a slice to automate our mundane tasks.

For loops

Loops and Slices go together like milk and cookies, and GO a unique range syntax for going through a slice, element by element and value by value.

Suppose you had data about the prices of paper you were selling and needed to update them to account for inflation.

package main

import "fmt"



func main() {
    paperPrices := []float32{1.00, 2.00, 4.00, 8.00, 16.00, 32.00, 64.00, 128.00}
    inflatedPaperPrices := make([]float32, len(paperPrices))
    for i, v := range paperPrices {
        inflatedPaperPrices[i] = (v * 0.08) + v
    }
    fmt.Println(inflatedPaperPrices)
}

Notice that the 'make' keyword was used when declaring the inflatedPaperPrices slice. The make statement is used in GO to create variables with predetermined lengths and types. It is often best practice and, in this case, must be done.

Let's break it down, starting with 'i' and 'v'– these are the for loop variables that only exist within the for loop and may be named anything, but typically 'i' and 'v' are used by tradition. Because 'i' can be thought of as 'index' and 'v' as 'value'.

So, range lets us iterate (go through) a slice and access either the value or index or both. The range syntax is a shortcut to write a for loop in GO. The code above could be written in a longer form like so.

package main

import "fmt"



func main() {
    paperPrices := []float32{1.00, 2.00, 4.00, 8.00, 16.00, 32.00, 64.00, 128.00}
    inflatedPaperPrices := make([]float32, len(paperPrices))
    for i:=0; i < len(paperPrices); i++ {
        inflatedPaperPrices[i] = (paperPrices[i] * 0.08) + paperPrices[i]
    }
    fmt.Println(inflatedPaperPrices)
}

Conclusion

Now that the basics of slices have been covered, let's move on.

Linode + DEV Hackathon

Toul — Thu, 09 Feb 2023 18:52:33 +0000

What I built

Gitty Up

It’s a web app where a user can create an account and add an admin GitHub.com token so that they can run their GitHub org against security best practices;

For each repo present in the Org. with a single report generated.

Note: It currently does not support privately self-hosted GitHub Enterprise Integration.

Category Submission:

SaaS

App Link

GittyUpSec.com

Screenshots

Description

Used for analyzing an organization’s repos at scale to show which could use hardening for security best practices with GitHub.com's available features

Link to Source Code

GittyUp

Permissive License

Background

(What made you decide to build this particular app? What inspired you?)

I recently obtained my CISSP and as part of retaining it continuing professional education (CPE) credits are required.

So, I watched an ISC^2 presentation over the troubles of securing GitHub Repos, which counts as 1 CPE credit.

I was shocked at how many Fortune 500 companies were being breached due to misconfigured GitHub repos.

Hence, I thought it could be a fun Friday night project to build a simple web app that could be used in the cloud or ran locally to check an Orgs security posture for GitHub.

Hence, GittyUp is built in GO which makes it easy to share across operating systems.

Later, I plan to create a CLI version of it as well as a Docker containerized version to make it even easier to use on one’s local computer.

I really hope it can help with stopping the data breaches caused by poor GitHub Repository Configuration.

How I built it

(How did you utilize Linode? Did you learn something new along the way? Pick up a new skill?)

I learned how to use Linode servers for running a web app which was tricky as it required installing it as a service on the Linode server. However, using Docker could make it easier as Linode has a Docker based server. But I kept it simple since it was a brief hackathon.
I also learned how to map a namecheap.com domain to the Linode server IP which was really easy to do in the Linode Console. It was just a click of the button and editing a few records within the NameCheap control panel.
I also learned how to use Linode Database Clusters which were also easy to set up in the console and upon set up provided all the credentials in an easy to view manner for connecting to the database. However, I opted to install the DB locally on the Linode server to reduce costs because I didn't want to go over the credit nor use a virtual DB/CPU.

Additional Resources/Info

How I obtained my CISSP

Toul — Wed, 25 Jan 2023 18:15:48 +0000

Intro

The Certified Information Systems Security Professional or CISSP is known for its rigorous exam and challenging requirement of needing at least 5 years of experience working in security-related roles.

I'm happy to say I was able to pass on the first attempt and would like to share my experience and study path with others interested in the CISSP.

I. Career Background

DevSecOps engineer for 4 1/2 years building security features for a platform in AWS cloud with Python, Go, and Kubernetes which obtained the ISO 27001 & ISO 27002 type I and Type II. During that time, I also received the AWS security specialty certification. Then moved to a whole security infrastructure security analyst job for about 5 months before attempting the CISSP Exam.

I felt that being in a DevSecOps role building a platform was advantageous since most of my day-to-day work revolved around the 8 tested domains of the CISSP;

Security and Risk Management
Asset Security
Security Architecture and Engineering
Communication and Network Security
Identity and Access Management (IAM)
Security Assessment and Testing
Security Operations
Software Development Security

II. Study Plan

II.a Get a Smaller Cert First

Obtaining a cert or two before going after the CISSP will be helpful because it will aid in building/refreshing study skills and building confidence. So, I first went after the AWS Security Specialty certification and recommend readers to do the same by selecting one of interest for themself.

II.b Books, Courses, and Bootcamp

All in One cover to cover

I read it on my kindle over a month by aiming for 1-3% a day before bed, spacing it out helped me since the material is dry and is what I would recommend for all the books provided. But some folks are able to read them all in a month. In the end go at the speed that works for you and at which you can retain information without falling asleep.

Thors course and Boson questions

I didn't use Thors Course at all— the material felt redundant with info found in All in One and Official Study Guide. Also, I wouldn't say I liked that I had to set the play speed for each video manually to x2, so it interrupted me while working and listening. However, it is a well done video course for those who prefer videos.

Official Study Guide and Official Study Guide test questions bundle

I went through every question at least once until I got 90% of them right. For those that might not be aware within Official Study Guide books there are registration codes for Wiley's digital practice exams which I strongly recommend.

Training Camp week Bootcamp

I did the BootCamp because the company offered to pay with no strings attached, so I figured sure why not. It was a grueling 5 day 12 hour a day experience with great books provided. Yet, I didn't read the books that came with that course felt redundant since I had already read the others.

However, I took lots of notes from the in-class session on the digital pad (my style of learning, which was especially helpful for the cryptography sections.

I focused on the "test-taker mentality" that the course instructor taught. Like how to select the best answers for the CISSP exam and how to think like a manager (I think this was most beneficial but can be found online pretty easily).

Pocket Prep phone app

I tried it but found it to be lesser than the already paid-for OSG tests and questions.

I didn't like the paywall since I had already paid for other resources and frankly the official resources are more than enough despite what others might say.

Doing, all the above took around 6 months to a year to accomplish. I prefer to space things out but others might prefer prepping in a shorter amount of time.

What is most important is finding a routine and sticking with it which for me was typically reading before bed and doing at least one practice exam a day of 120 Questions.

III. Days leading up to test

I kept doing OSG practice tests and
listened to YouTube videos by Larry Greenblatt and Kerry for thinking like a manager for the exam

IV. Day of test

I didn't sleep the night before from nerves, so I arrived with only 4 hours of sleep and went through the exam in 175 Qs at around 143 mins.

I took a break when I got frustrated with the vagueness of some questions and just started to click out of annoyance.

IV.a Test taking strategy

I focused on picking the best answer and trusting my gut.
It would be mentally exhausting to pick the 'right' answer each time versus the other choice, so I trusted my gut after reading the question 3 times.

Read each answer choice once
Start with the Last answer choice, then read up
Pick the Cheapest option if stuck between choices
Pick the thinking option if stuck between 2 choices
Test Qs review

The technical questions were decently similar to tech questions from OSG in terms of format 1-3 sentences
Overall, though, the questions weren't anything like the study material as anyone who's taken it will tell you.

Conclusion

I hope my shared plan helps you if you're going after the CISSP. I'm happy to answer any other questions as well!

Ch. 4 Functions

Toul — Fri, 06 Jan 2023 22:09:31 +0000

You've already seen func's multiple times so far, but let's take this chapter to understand them better and when to use them when automating work.

Functions are reusable work units for a program to use, and they save programmers from repeating themselves.

You might hear this paradigm as D.R.Y. when speaking with other coders, which stands for "Don't repeat yourself".

Functions are like small programs within your program. And GO, in particular, must always have the func main() {} within the main.go file.

The main func is to tell the compiler (go build) that this is where the code starts. Remember, computers execute code line by line, so it helps to tell them which line to begin with.

I.Parts of a function

Let's start with a basic function and try to understand what each part of it is called and what it is responsible for.

// ex. 1
package main 

func NameIs(name string){ // (1)
    fmt.Printf("Your name is: %s", name)
}

func main() {
    NameIs("Gopher") // (2)
}

(1) The characters succeeding the 'func' keyword give the name to the 'func'.

In this example, it is correct to say the function's name is, well, NameIs.

And the characters within the parentheses 'name string' is the accepted argument(s).

Note: There can be more than one argument that a function can to do work on.

(2) It Is known as the 'function call,' or the function is being 'called/invoked'. That is a fancy way of saying, "the function is being used".

I.a When to get func-e (funky)?

Frequently whenever you're writing code, you might get it working-- and that is fine and a noble goal on the first pass. However, on the second pass (immediately, once it is working), it's time to refactor, which means doing things like reducing repetition by using functions.

I.b Example

Suppose we say hello to a bunch of readers without using a function. Here's how repetitive it will look.

// ex. 2
package main 

func main() {
    fmt.Printf("Hello %s", "Gopher")
        fmt.Printf("Hello %s", "Gopher2")
    fmt.Printf("Hello %s", "Gopher3")
        fmt.Printf("Hello %s", "Gopher4")
    fmt.Printf("Hello %s", "Gopher5")
        fmt.Printf("Hello %s", "Gopher6")
    fmt.Printf("Hello %s", "Gopher7")
        fmt.Printf("Hello %s", "Gopher8")
    fmt.Printf("Hello %s", "Gopher9")
        fmt.Printf("Hello %s", "Gopher10")

}

Let's do a refactor to make it a bit DRYer.

// ex. 3
package main

import "fmt"

func greetReaders(n []string) {
    for _, name := range n {
        fmt.Printf("\nHello %s", name)
    }
}

func main() {
    rdrs := []string{
        "Gopher",
        "Gohper2",
        "Gopher3",
        "Gohper4",
        "Gopher5",
        "Gohper6",
        "Gopher7",
        "Gohper8",
        "Gopher9",
        "Gohper10",
    }
    greetReaders(rdrs)

}

II. Multiple different kinds of arguments

Suppose we wanted to print a reader's name and age. Then we'll need string type data and number type data. In GO the arguments can be a mix of different types like string and int, not just a mono-type.

// ex. 5 Multiple Argument types
package main

import "fmt"

func HappyBirthday(n string, age int) {
    fmt.Printf("Happy birthday %s, You're turning %d", n, age)
}

func main() {
    HappyBirthday("Go", 20)

}

III. `return` values

So far, the functions defined haven't used the 'return' keyword, which means they're only doing something with the data passed in but not giving it back.

Let's go back to our even/odd examples and sort integer arrays into odd and even.

// ex. 4 Returning values
import "fmt"

func EvenOdd(n []int) ([]int, []int) {  // (1)
    var odd, even []int
    for _, num := range n {
        if num%2 == 0 {
            even = append(even, num)
        }
        if num%2 == 1 {
            odd = append(odd, num)
        }

    }
    return odd, even // (2)
}

func main() {
    num := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
    odd, even := EvenOdd(num) // (3) 
    fmt.Println("Odd: ", odd)
    fmt.Println("Even: ", even)

}

(2) The 'return' keywords say at the end of this function call, give the value to the caller. The big idea here is that the 'value' returned can be 'assigned' to variables, which can then be passed further along in the program.

Notice, in GO, that you can return multiple values and assign them at once in (3). However, this can be tricky, so it's not recommended as you're starting out.

(1) The astute reader probably caught the additional parentheses following the accepted arguments; ([]int, []int). The second set of parentheses is required when returning multiple values. It lets the reader know the types expected after a successful invocation of the func.

Similarly, you can return multiple different data types as well.

// ex. 5 Returning multiple values 
package main

import "fmt"

func diffVals(n string, age int) (string, int) { // (1)
    return n, age
}

func main() {
    name, age := diffVals("Gopher", 20)
    fmt.Printf("name: %s, age: %d", name, age)
}

(1) Shows that a string type and int type will be returned at the end of a successful function call.

As you write code to solve problems, your programs will be more extensive than 20 lines.

Having functions that return data makes it simpler to keep track of what's going on in your program for you and other readers.

IV. Local variables and Global Variables

In all our code so far, we've mainly been using local variables, and now it is time to discuss what that means and what global means.

The distinction is that a local variable and its value are only accessible within the block of code in which it exists. Whereas a global variable may be accessed outside of the code block and across all of your program files. In general, global variables are frowned upon in GO programs, but in other languages, they're not so frowned upon.

Let's see an example.

// ex. 6 Globals are tricky
package main

import "fmt"

// global variables
var Author = "Gopher"
var Age = 20

func LocalAuthor(name string, age int) {
    Author = name
    Age = age
    fmt.Printf("\nAuthor: %s, \nAge: %d", name, age)
}

func main() {
    LocalAuthor("Gopher2", 40)
    fmt.Printf("\nAuthor: %s, \nAge: %d", Author, Age)

}

Above, the global variables have their values reassigned within the function call of LocalAuthor, which might cause problems in other parts of the program if the expected values were "Gopher" and 20.

To get the expected behavior, define local variables within the function 'n' and 'a' for name and age, respectively.

// ex. 7 Locals are preferred
package main

import "fmt"

// global variables
var Author = "Gopher"
var Age = 20

func LocalAuthor(name string, age int) {
    n := name // don't reference the global variables
    a := age
    fmt.Printf("\nAuthor: %s, \nAge: %d", n, a)
}

func main() {
    LocalAuthor("Gopher2", 40)
    fmt.Printf("\nAuthor: %s, \nAge: %d", Author, Age)
}

V. Error handling

One of the few areas where GO receives complaints is with error handling in that it is often verbose and redundant. However, the idea is that errors should be explicitly handled and error situations described.

Let's set up a function that will return an 'error' type if the received argument is 'empty'.


package main

import (
    "errors"
    "fmt"
    "log"
)

// Hello returns a greeting for the named person.
func Hello(name string) (string, error) {
      // If a name isn't received then there's no one to greet and it should return an error
    if name == "" {
        return "", errors.New("Err: empty name")
    }
        // otherwise great the person and return a nil for error
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message, nil
}

func main() {
    // Set properties of the predefined Logger, including
    // the log entry prefix and a flag to disable printing
    // the time, source file, and line number.
    log.SetPrefix("greetings: ")
    log.SetFlags(0)

    // Request a greeting message.
    message, err := Hello("")
    // If an error was returned, print it to the console and
    // exit the program.
    if err != nil {
        log.Fatal(err)
    }

    // If no error was returned, print the returned message
    // to the console.
    fmt.Println(message)
}

Error handling is a must if you're going to be building functions that you intend to share with the world or a team or with your future self.

However, just starting out it might not be as necessary when you're hacking something together.

But, now you are aware of the general style if you should be happen to digging around through some package documentation.

Conclusion

Functions are an essential paradigm in any program language-- in fact there's languages that are purely functional. The key takeaways are that as a reader of a function you'll probably be most interested in what arguments it takes and what values it returns, not so much the code is within the function.

Ch. 3 Flow Control

Toul — Tue, 29 Nov 2022 19:47:05 +0000

In the previous chapter, we covered the basics of GO data types and, in a few examples, used flow control to print messages.

In this chapter, we'll use what we learned about comparison operators and boolean values to learn more about flow control.

Elements of Flow control

Programs are like water in a river because they tend to flow in one direction. And like water in a river, parts of it can go off into separate outlets based upon the river's conditions, such as a boulder in the stream or a dam.

However, unlike water in a river, it's much easier to divert the flow of a program.

To do so, we use conditions to evaluate a variable's value or the output of a function and execute a different code block.

Let's use an example with comments to see.

We are using the familiar 'if' from the previous chapter.

// Ex. 1 Tell me if a number is even or odd
package main

import (
    "fmt"
    "math/rand"
)

func main() {
    // use the rand library to generate a random integer.
    n := rand.Intn(100)
    // 'if' condition
    if n%2 == 0 {
        // code block that's executed if the condition is true
        fmt.Printf("Number is even: %d", n)
    }
    // code block that's executed if it isn't true
    fmt.Printf("Number is odd: %d", n)
}

In this program, we're checking whether a 'random' integer number is even or not via the modulo operator %, which is a fancy way of saying 'dividing with remainders'.

If you recall, an even number can be divided in two without any remainders, whereas an odd number cannot.

Don't worry about the math. Just note that the logic of the program changes based on the condition, which is the 'random' value of the n variable.

Now, let's introduce the rest of the gang for flow control.

Flow Control Statements

'if' statements

These are the most used control statements, and you'll almost always use them when adding 'logic' to your programs.

The general pattern is that your program has a chunk of code that will only be executed if the condition is considered 'true' or 'false.'

'else' statements

Technically, in the previous 'if' example, we could've had an 'else' statement to print the 'number is odd:' part, but we kept it cleaner by leaving it out, which is a preference amongst programmers.

// ex. 2 else
package main

import (
    "fmt"
    "math/rand"
)

func main() {
    // use the rand library to generate a random integer.
    n := rand.Intn(100)
    // 'if' condition
    if n%2 == 0 {
        // code block that's executed if the condition is true
        fmt.Printf("Number is even: %d", n)
    } else {
        // code block that's executed if it isn't true
        fmt.Printf("Number is odd: %d", n)
    }

}

Else statements say 'hey, if this piece of logic turns out to be false or something else, then do this.'

Typically, 'else' statements aren't preferred because they aren't explicit and will catch only when the condition is false.

Let's introduce the else's, cousin.

else if

Here, we can communicate what we want to happen 'if' the first condition evaluates to 'false' and explicitly define what should happen.

// ex. 3 else if 
package main

import (
    "fmt"
    "math/rand"
)

func main() {
    // use the rand library to generate a random integer.
    n := rand.Intn(100)
    // 'if' condition
    if n%2 == 0 {
        // code block that's executed if the condition is true
        fmt.Printf("Number is even: %d", n)
    } else if n%2 == 1 {
        // code block that's executed if it isn't true
        fmt.Printf("Number is odd: %d", n)
    }

}

switch

The 'switch' control flow works much the same as using 'if' 'else' or 'else if' but presents differently in the form of 'cases'. A 'case' is the same as a condition and may be preferred by those with a mathematical background. Either style works; use whichever makes sense to you.

// ex. 4 switch
package main

import (
    "fmt"
    "time"
)

func main() {

    // You can use commas to separate multiple expressions
    // in the same `case` statement. We use the optional
    // `default` case in this example as well.
    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("It's the weekend")
    default:
        fmt.Println("It's a weekday")
    }

    // `switch` without an expression is an alternate way
    // to express if/else logic. Here we also show how the
    // `case` expressions can be non-constants.
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("It's before noon")
    default:
        fmt.Println("It's after noon")
    }
}

In the above, we say 'switch' based upon the following 'case' and pass in some data. The same again can be accomplished by using 'if' and 'else if'

// ex. 5 convert switch to if else
package main

import (
    "fmt"
    "time"
)

func main() {
    if t.Hour() < 12 {
        fmt.Println("before noon")
    } else if t.Hour() > 12 {
        fmt.Println("it's after noon")
    }
}

In general, I prefer using 'switch' and including the optional 'default' case because I find it easier to test my 'cases' and to convey to others what I'm trying to do with my code.

Loops

Now that we have some logic to control a program's flow, it's time to introduce 'loops'. A loop is a way we tell computers to "do work for x amount of times". Let's combine it with loops to make a more intelligent program.

A 'for' loop also uses a condition to do its work, but it works 'until' that condition is satisfied. So, for example, the saying 'a thousand thanks' we'll have a program that will say 'thank you' a thousand times based upon a reader's name.

// ex 5. If you're a reader, then a thousand thanks
package main

import "fmt"

func main() {
   fmt.Println("Enter your name")
   var n string
   fmt.Scan(&n)
   switch {
   case n == "Toul":
         fmt.Printf("The author is %s ",  n)
   default:
     // a thousand thanks if you're not the author
      for i := 0; i < 1000; i++ {
         fmt.Printf("\ni: %d Thank you %s for reading", i, n)
      }
   }
}

In the above the 'for' loop syntax is for initial condition; compare ;if not met then do another { // work to be done }

In most programming languages, it is common to start at '0', so keep this in mind when working with arrays, slices, and initial loop conditions.

Okay, let's have some fun by building a few small games to show your friends and family at the winter holiday parties.

Don't worry if some syntax is unfamiliar. We want to focus on building muscle memory and familiarity with GO. So, try your best to copy the code and get in running. If you have any troubles at all the source code is available

Guess the Number

In this first game we'll have the computer pick a random number and then try to guess it by inputting guesses, but the catch is we only get '3' attempts!

But, we'll give the user clues to increase the chances of winning within 3.

package main

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

func main() {
   fmt.Println("Game: Guess a number between 0 and 10")
   fmt.Println("You have three(3) tries ")

   source := rand.NewSource(time.Now().UnixNano())
   randomizer := rand.New(source)
   secretNumber := randomizer.Intn(10)

   var guess int

   for try := 1; try <= 3; try++ {

      fmt.Printf("Attempt: %d\n", try)
      fmt.Println("Enter your number: ")
      fmt.Scan(&guess)

      switch {
      case guess < secretNumber:
         fmt.Printf("Sorry, wrong guess ; number is too small\n ")
      case guess > secretNumber:
         fmt.Printf("Sorry, wrong guess ; number is too large\n ")
      case guess == secretNumber:
         fmt.Printf("You win!")
      case try == 3:
         fmt.Printf("Game over!!\n ")
         fmt.Printf("The correct number is %d\n", secretNumber)
      default:
         fmt.Println("I don't recognize that input. Try a number like '1'")
      }
   }
}

Advanced: Rock, Paper, Scissors

Now, for a more fun and more advanced example to wet your programmer appetite.

package main

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

func getInput() string {
   // get input and use strings package to convert to lowercase b/c this is a good practice when working with inputs 
   // in general
   fmt.Print("Pick [r]ock, [p]aper, or [s]cissors:   ")
   var input string
   fmt.Scanln(&input)
   return strings.ToLower(input)
}

type Move int

const (
   Rock Move = iota
   Paper
   Scissors
)

var validInput = map[string]Move{
   "r":        Rock,
   "rock":     Rock,
   "p":        Paper,
   "paper":    Paper,
   "s":        Scissors,
   "scissors": Scissors,
}

var inputs = [...]string{
   Rock:     "Rock",
   Paper:    "Paper",
   Scissors: "Scissors",
}

func checkInput() Move {
   // start a loop until we get valid input
   for {
      // Does the user input match the map validInput?
      if move, ok := validInput[getInput()]; ok {
         fmt.Println("Player Chooses", inputs[move])
         return move
      }

      fmt.Println("I didn't understand your choice, please retry")
   }

}

var compare = [...]string{
   Rock:     "You Tied.",
   Paper:    "You Lost.",
   Scissors: "You Win!",
}

func main() {
   // for {} says do this until the user wants to stop with ctrl+c which is the universal way to kill a program 
   // that's running in the terminal.
   // this is also known as 'while' loop in other languages and is how video games work (while user playing keep 
   // running game engine) 
   for {
      rand.Seed(time.Now().Unix())

      // Get Valid Player Input
      userChoice := checkInput()

      // Randomly Assign Computer Choice
      computerChoice := Move(rand.Intn(3))

      computerInput := inputs[computerChoice]

      fmt.Printf("Computer chooses: %s\n", computerInput)

      // Check to see who won
      fmt.Printf("Result: %s\n",
         compare[((computerChoice-userChoice)%3+3)%3])
   }

}

Ch.2 GO Basics

Toul — Mon, 14 Nov 2022 15:53:31 +0000

In this chapter, I'll cover the basics you'll need for writing programs in GO. Things like using the toolchain, data types, and some handy conversions. I will use plenty of examples in the upcoming sections. It's okay if they do not make sense; we aim for familiarity, not mastery. That said, the best way to learn any programming language is to code along to build muscle memory, so crack open your new installation of Visual Studio Code editor.

Note: Chapter 2. GO Basics source codein case any code causes errors or if you get a little lost.

I. The GO Toolchain

One thing that makes developing with GO so vastly different from Python or Java is that it comes with native toolchain support from the creators of the language for an easy way to manage GO codebases.

In the first chapter, we installed GO, including the toolchain. If you remember, we used 'go build -o' or 'go run main. go' to execute the hello world program, which are commands that are part of the GO toolchain.

We'll briefly tour the few commands you use most when writing GO.

I.a 'go mod'

Go mod is used for dependency management. It makes it such that when you download another GO project, you'll be guaranteed that the code will work and not be broken due to dependencies.

Typically, you'll only need to run it every once in a while.

So here are the two commands you'll need most.

go mod init

You use go mod init to declare that the code you're working on is a module that requires x,y, and z dependencies; the dependencies will be shown within the go.mod that is created.

Typically, you use the format

go mod init github.com/<yourUserName>/nameOfProject.

go mod tidy

Go mod tidy eliminates dependencies that aren't used so that your codebase stays light.

To use it run,

go mod tidy

I.b go get

So, GO requires that the dependencies for a project be installed locally on your machine as you develop and if they aren't then you'll see an error like:

ERROR github.com/pkg/name is not installed.

And to solve it run,

go get github.com/pkg/name

But the catch is that you must have done go mod init first.

I.c 'go fmt'

There are many heated arguments on the internet about how a programming language's codebase should look in terms of format.

But with GO, there is only one option.

Imagine, for some reason, that you can't access Visual Studio Code, or the extension stops working, and the go code you wrote from chapter 1. Setting Up Developer Environment looks like this:

package main 
import "fmt"
func main(){
fmt.Println("Hello, world!")
}

Then to make it GO-compliant, all you'd need to do is,

go fmt main.go

And then your code will look like this.

package main

import "fmt"

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

Although having a linter like the GO extension installed is preferred to this method, it is good to know for odd occasions when you don't have it.

I.d 'go run'

Compiles and runs your GO program all at once very useful when you're working on new code and want instant feedback without having to do 'go build' first.

go run main.go

I.e 'go build'

You'll run this when you've finished your program and want to use it as an executable. When you're done building a Command Line Interface (CLI) tool or a Web App with a server component, you'll want executables.

And what's better is that with go build, you can specify which operating systems you want it to run on.

go build -o hello env GOOS=target-OS GOARCH=target-architecture

Don't worry if this doesn't make sense right now. Just note that when you want to take your program executable to a different operating system, it is super easy to do by using GOOS and GOARCH environment variables.

I.f 'go test'

Testing your code speeds up the development process and is often a requirement in the professional world, so having support right out of the box is fantastic.

Testing is a complete topic worthy of a book or blog post. If you want to look for an in-depth explanation of it, then read my post GO Test Driven Development

Otherwise, know that if you see _test.go files within a codebase that you can run

go test .

To run the tests for that codebase.

II. Data Types

Computers, unlike humans, need precise instructions. Part of the specificity of the instructions is what data type it is to process.

So, we'll cover the significant data types in the next section that you'll most likely use and encounter while working with GO.

II.a Integers

Integers are your whole numbers, meaning there are no decimal points.

You use the signed integer type if a number can be negative. Otherwise, the unsigned type should be used.

Signed

Imagine you have a program to analyze your bank account balance after paying monthly bills, and you've unfortunately had to think about a case where you are negative money.

You've overspent and might need a credit card, loan, or part of the next paycheck to pay the remainder.

So, in this case, your result could be negative, which tells us to use a signed integer.

First, create a new directory, 'ex1', and then create a new file named 'main.go'.

And type the following.

// ex1
package main

import "fmt"

func pay(money, bills int) int {
   return money - bills
}

func main() {
   var paycheck, bills int = 4000, 5000
   fmt.Printf("bank account balance: %d\n", pay(paycheck, bills))
}

then run

go run main.go

And you'll see you indeed might have a problem.

Now that you know when you might use signed integers, it is worth mentioning that Go lets you specify how many bits an integer can contain with int8,int16, int32, and int64, but for most of the readers, int will more than get the job done.

unsigned

Unsigned integers will not be negative, so if we take the same code and swap 'int' with 'uint', you'll see that it breaks.

// ex2
package main

import "fmt"

// changed int to uint
func pay(money, bills uint) uint {
   return money - bills
}
func main() {
   // changed int to uint
   var paycheck, bills uint = 4000, 5000
   fmt.Printf("bank account balance: %d\n", pay(paycheck, bills))
}

It outputs a nonsensical "18446744073709550616" instead of '-1000' as in the previous example.

Just like with 'int', there are uint8, uint16, uint32, and uint64 versions, and just like with 'int' most readers will only need 'uint.'

Floats

Floats are your decimal numbers; by default, they can handle both positive and negative numbers. In general, I'd use a float for the calculation above because very rarely is anything, only whole numbers.

I recommend something other than the float if you're on a project where memory is a concern or if you know that decimals will not appear.

// ex3
package main

import "fmt"

// int -> uint -> float32 if you're coding along
func pay(money, bills float32) float32 {
   return money - bills
}
func main() {
   // int -> uint -> float32
   var paycheck, bills float32 = 4000, 5000.0
   fmt.Printf("bank account balance: %f\n", pay(paycheck, bills))
}

However, there is no 'float' like with 'uint' or 'int', so you must declare either 32bit or 64bit-sized floats. Don't worry float32 will handle most of your use cases.

An explanation about bits is outside this book's scope, and it isn't necessary to write GO code to automate your daily tasks.

II.b string

The data you're reading in this book and often contains within documents is of the 'string' data type. And chances are this is the most common data type you'll be using and seeing.

In GO and many other languages, string types are represented with quotation marks. Like so

// ex4
package main

import "fmt"

func main() {
   var example string = "Hello, world!"
   fmt.Printf("%s", example)
}

II.c booleans

Boolean variables are either true or false, you'll use this when you're checking for conditions in a program, and we'll use them later.

// ex5
package main

import "fmt"

func main() {
   //Default value will be false
   var a bool
   fmt.Printf("a's value is %t\n", a)
}

III. String Concatenation

String concatenation is the idea of adding two strings together to make one string, and as such, it uses the '+' symbol.

// ex6
package main

import "fmt"

func main() {
   var s1 string = "Hello "
   var s2 string = "world!"
   fmt.Printf("%s", s1+s2)
}

IV. Variables

We've used variables throughout the examples, as shown by the 'var' keyword. Think of a variable like an empty box that you have left over from moving.

Before you move, you put stuff inside of it, and if you are of the well-organized type, you might even have the same type in one box.

For example, if packing a box for the kitchen, you might have a box labeled 'kitchen-glasses', and within all glasses from your cabinets.

So, only one data type goes into the variable, as only glasses go into the kitchen-glasses box.

And this is how GO expects you to use variables in a very organized manner.

However, there is a trick that you can use to avoid having to type 'var' and the type the data is explicitly, and that's the ':=', which is called the short declaration operator. But you can only do it within functions.

Here's what I mean:

// ex7
package main

import "fmt"

func pay(money, bills int) int {
   return money - bills
}
func main() {
   // var, int -> :=
   paycheck, bills := 4000, 5000
   fmt.Printf("bank account balance: %d\n", pay(paycheck, bills))
}

So, the 'main()' is a 'func'; hence, we can use the ':=', which is generally the preferred way to save on words. In codebases, less is more.

IV.a Assignment statements

Unlike the ':=' that we previously discussed, an assignment statement uses '=', which we used in all the examples, and it requires us to use 'var' and the data type after the variable name.

E.g.

// ex8
package main

import "fmt"

func main() {
   var example string = "Gentle reminder"
   fmt.Printf("%s", example)
}

In this, we are saying that example is a variable of the typed string, and we are assigning the string "Gentle reminder" to be stored within it.

Naming Conventions

Typically, GO programmers prefer short, concise variable names with no '_' or '-', called camelcase and kebob case, respectively.

So, you'll see terms for variables being as few characters as possible and function names like so:

// ex9
package main

import "fmt"

func getUserName() string {
   return "Reader"
}
func main() {
   n := getUserName()
   fmt.Printf("Hello Dear %s", n)
}

Naming things like this is the opposite of Python's preference for names like 'name_of_user = get_user_name(),' which encourages spelling things out as much as possible.

V. Type Conversions

Imagine you have data in a document of '1.99' and want to use it as a float for some calculation. Sometimes, you'll find variables and want to change them to another type. Doing so is called casting or conversion in programming speak, and it is probably most familiar with string data.

Here are a few to keep in mind as you work with GO.

golang string to int

// ex10
package main

import (
   "fmt"
   "reflect"
   "strconv"
)

func main() {
   strVar := "100"
   intVar, err := strconv.Atoi(strVar)
   fmt.Println(intVar, err, reflect.TypeOf(intVar))
}

int to string

// ex11
package main

import (
   "fmt"
   "strconv"
)

func main() {
   i := 10
   s1 := strconv.FormatInt(int64(i), 10)
   s2 := strconv.Itoa(i)
   fmt.Printf("%v, %v\n", s1, s2)
}

golang bytes array to string

// ex12
package main

import "fmt"

func main() {
   s := string([]byte{65, 66, 67, 226, 130, 172})
   fmt.Println(s)
}

golang bool to string

// ex13
package main

import (
   "fmt"
)

func main() {
   B := true
   str := fmt.Sprintf("%v", B)
   fmt.Println(str)
}

VI. Comparisons

They are rarely used alone and typically go with control-flow or conditional statements, which we'll go over later, but I'm showing them here to build familiarity.

equal to

Compares whether or not two values stored in variables are equal.

// ex14
package main

import (
   "fmt"
)

func main() {
   fmt.Println("let's see if these two identical strings evaluate to equal")
   s1 := "hi"
   s2 := "hi"
   // okay, I showed a little conditional flow here
   if s1 == s2 {
      fmt.Printf("yes, they are!")
   }
}

not equal to

// ex15
package main

import (
   "fmt"
)

func main() {
   fmt.Println("let's see if these two non-identical strings evaluate to equal")
   s1 := "hi"
   s2 := "these are not the droids you're looking for"
   // okay, I showed a little conditional flow here
   if s1 != s2 {
      fmt.Printf("They're not the same string!")
   }
}

greater than

// ex16
package main

import (
   "fmt"
)

func main() {
   bills := 13642.32
   paycheck := 10000.00
   if bills > paycheck {
      fmt.Printf("Maybe I should update my resume...")
   }
}

less than

// ex17
package main

import (
   "fmt"
)

func main() {
   paycheck := 13642.32
   bills := 10000.00
   if bills < paycheck {
      fmt.Printf("alright, alright, alright")
   }
}

greater than or equal to

// ex18
package main

import (
   "fmt"
)

func main() {

   bills := 13642.32
   paycheck := 10000.00
   if bills >= paycheck {
      fmt.Printf("I'll never gonna financially recover from this")
   }
}

less than or equal to

// ex19
package main

import (
   "fmt"
)

func main() {
   paycheck := 13642.32
   bills := 10000.00
   if bills <= paycheck {
      fmt.Printf("seems risky.")
   }
}

Conclusion

Wow, that was a lot of examples. Congrats on making it this far. Know that as you code along, you are getting more and more comfortable with go! But it's also tiring learning so many new things at once, so make sure to have a snack and rest before heading on to the next chapter.

Now that all of the basics of GO are in place, we can move on to introducing flow control or logic to our programs. So see you in Chapter 3. with, of course, plenty of examples!

Ch.1 Developer Environment Set Up

Toul — Mon, 07 Nov 2022 16:14:06 +0000

Hello, all thank you for signing up for the free e-book Automate the Boring Stuff with GO.

I'll be delivering a chapter each Monday, so keep an eye out.

Intro

A developer environment can mean several things, but for you, it means getting your laptop or desktop configured to write GO and run GO programs.

I'll show you the easiest ways of installing GO for the two most common personal computer operating systems; Windows and macOS.

Through my years of getting people started, I know package managers are the easiest; a package manager is a tool that makes installing and managing software easier. I recommend this route because the GOPATH tends to trick folks up. But you don't need to worry about that if you follow along. I'll show the links for the package manager for both a Windows and Mac machine.

Notice: If you're ever stuck on any code snippets, then make sure to star or bookmark the GitHub Repo Automate the Boring Stuff with GO,
which will contain all the source codes for each chapter and the text.

So let's get going.

I. Installing GO

I.a Windows

I recommend first installing Chocolatey, which will make installing software on a Windows-based machine effortless.

To install it, open your Windows Powershell in Administrative mode and paste the following:

> Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))

Then type the following to install GO:

PS C:\ choco install golang

Once it's done, then you're ready for part II.

I.b MacOSX

For Mac, I recommend first installing Brew if you haven't already.

To do so, open your Terminal app and type the following:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Once it's done, do the following:

brew install go

Now, you're ready for Part II.

II. Installing Visual Studio Code (VSC)

Visual Studio Code (VSC) is a text editor. A text editor is standard tool developers use daily to make writing code more manageable. It is similar to how writers use Microsoft Word to create books or essays.

There are a lot of choices when it comes to text editors, and not all of them are free. We'll stick with Free so that all readers can follow along.

And the current champ of free text editors is Microsoft's Visual Studio Code. I recommend using it because there's a lot of support online. And by support, I mean you can ask Dr.Google for help whenever you get stuck.

Here's the official Visual Studio Code Download link.

Click the icon for your Operating System, and It'll begin installing.

Once it is done, double-click the Visual Studio Code icon and navigate to the extensions section of VSC.

Type GO, then click install for the first result.

This extension will provide automatic syntax highlighting and formatting, similar to how Microsoft's Word provides the red squiggle when you've mistyped a word.

Once it has finished installing, you're ready for the next part.

III. Writing 'Hello World'

Before we write your first program, let's verify that go is installed and accessible within VSC.

Open a new terminal within VSC.

Then type

> go

And press 'enter,' and you'll see something like this.

If you don't, reach out to me on Twitter @toul_codes, and I'll try my best to help debug what's happening.

Now that we've confirmed everything is lined up, it's time to write your first GO program.

First, create a new file within VSC (cmd + n / ctrl + n) and type out the following.

package main 
import "fmt"

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

Then hit (cmd + s/ctrl + s) and save it as 'main.go'.

Then on the terminal, type out the following.

go mod init github.com/<your-name>/automate-the-boring-stuff-with-go-ch1

Note This is using one of the features of the GO toolchain that manages dependencies. A dependency is someone else's code you use to save time writing your own code. In this case, the GO developer team and the formatting package named 'fmt.'

Don't worry if it doesn't make sense. The next chapter will investigate the GO toolchain and its most valuable features.

After the command is done running, you'll see a go.mod file next to your main.go file.

And in it, you'll see that your program requires go 1.19.3 or whichever version of GO you have installed. Don't worry; any version will work; that's the beauty of GO.

Now, you can compile your GO program and run it like so.

> go build -o hello
> ./hello
Hello, world

Alternatively, and the way I usually do it to save a step is to type

> go run main.go 
Hello, world

This will build and then execute your GO program all at once.

Conclusion

Wow! You've just tackled a lot of topics as a budding developer. This is a lot to take in for the first time. If your brain is aching, remember that's normal. So, take a snack break or a rest to reward yourself before going on to the next chapter. If you're feeling social, send me a Tweet with your celebratory snack of choice!

Introducing Automate the Boring Stuff with GO

Toul — Fri, 04 Nov 2022 13:20:54 +0000

Welcome to the Free E-book for Beginner Coders Interested in GO

If you're new to GO and a Beginner in programming then there's not really books or learning resources for you. Most GO related books expect you to have some programming experience and involve complex topics such as Web Application building.

If you're looking around in the GO communities online for advice, you'll hear things like 'just do the tour' or 'build it yourself' or the worst 'GO is so easy you can learn it in a day', which for a beginner isn't helpful at all and is discouraging.

However, with Automate the Boring stuff with GO we'll start from the basics of setting your development environment, go over GO, and then at the end build a bunch of useful programs.

Here's the outline for the second part of the book which contains the programming projects:

Part II. Ready, Set, GO

Chapter 8. Regex
Chapter 9. Reading and writing files
Chapter 10. Massive File management
Chapter 11. Downloading internet pages
Chapter 12. Excelling with GO - working with Spreadsheets
Chapter 13. Working with PDF and Word documents
Chapter 14. Working with CSV and JSON
Chapter 15. Getting a Grip on Dating
Chapter 16. Automate E-mailing and Texting
Chapter 17. Edit PNG and JPEGs

The first part will be all about the basics of GO and getting your computer ready to develop code.

Part I. All you need to get Going

Chapter 1. Setting up your Dev env
Chapter 2. Basics of GO
Chapter 3. Flow Control
Chapter 4. Functions
Chapter 5. Slices
Chapter 6. Maps and Structs
Chapter 7. String Manipulation

Work in progress

I'm writing this book in the open and will deliver one chapter a week, but please bear with me as this is my first time taking on such a task, so the writing might not be perfect.

But, that also means you can tell me when you're confused, and I'll go back to that chapter / section and add more to it or redo it altogether if it doesn't make sense.

So, without further ado here's the first chapter!

Chapter 0. Introduction

DEV Community: Toul

Get Automate the Boring Stuff with GO (e-book PDF)

Chapters 8,9,10, and 11

Chapter 8 - File Wrangling

Chapter 9 - Excelling with GO

Chapter 10 - PDF Hero

Chapter 11 - Web Scraping

Ch. 7 String Manipulation

II. Projects

Regex E-Mail finder from clipboard

Regex Password Complexity Checker

Quiz Builder

Ch 6. Maps

Syntax

Use case

Conclusion

Ch. 5 Slices

The Slice Data Type

Accessing values in a slice with Indexes

Using empty slices

Appending to a Slice

Getting a Slice's length with len() func.

Changing Values in a Slice with Indexes

Using Slices

For loops

Conclusion

Linode + DEV Hackathon

What I built

Gitty Up

Category Submission:

App Link

Screenshots

Description

Link to Source Code

Permissive License

Background

How I built it

Additional Resources/Info

How I obtained my CISSP

Intro

I. Career Background

II. Study Plan

II.a Get a Smaller Cert First

II.b Books, Courses, and Bootcamp

III. Days leading up to test

IV. Day of test

IV.a Test taking strategy

Conclusion

Ch. 4 Functions

I.Parts of a function

I.a When to get func-e (funky)?

I.b Example

II. Multiple different kinds of arguments

III. return values

IV. Local variables and Global Variables

V. Error handling

Conclusion

Ch. 3 Flow Control

Elements of Flow control

Flow Control Statements

'if' statements

'else' statements

else if

switch

Loops

Guess the Number

Advanced: Rock, Paper, Scissors

Ch.2 GO Basics

I. The GO Toolchain

I.a 'go mod'

go mod init

go mod tidy

I.b go get

I.c 'go fmt'

I.d 'go run'

I.e 'go build'

I.f 'go test'

II. Data Types

II.a Integers

Signed

III. `return` values