Unlocking the Power of Go: A Comprehensive Programming Course for Beginners

welcome to this comprehensive go programming course for beginners throughout this course you'll learn key

Concepts and techniques to write performant idiomatic go code you will be guided by the expertise of Lane Wagner

and Alan lers who combined have over 18 years of coding experience alongside mastering topics such as variables

function loops and more you'll also have the opportunity to apply your new found skills in seven real world projects

ranging from building an RSS aggregator to implementing authentication with API keys so get ready to unlock the

incredible potential of go go has been exploding in popularity recently it feels like all the most modern tech

companies are using go to build scalable backend infrastructure it actually makes a lot of sense Go's fast lightweight has

an amazing developer experience and is actually super easy to learn stick around and in just a few minutes I'll

explain the rest of the reasons why go could be a game changer for your coding career at this point I'll just introduce

myself really quickly I'm Lane the founder of boot. Dev and I've been writing go for a little over 7 years and

I've been building software for about 10 I've actually spent over 2 years designing this go course and I've taught

thousands of students with this material the feedback from all of my students over the last couple years is actually

been Incorporated in the course so everything is very battle tested and up todate I was actually just making some

updates yesterday so how does this course actually work well we're going to start by doing over 100 handson coding

lessons and exercises now when we're done with all of that you'll actually have a really strong grasp on the

fundamentals so at that point we'll go build a production ready back-end server Ino from scratch now I'm begging you

please do not binge watch this video tutorial hell is a very real place and it's a place that you will go if you

don't write your own code get your hands on the keyboard and write some code with me in fact you should actually be coding

ahead of me and only using my Solutions when you get stuck so head over to boot. and create a free account that's where

all of the code samples for this course are hosted now alternatively I have linked a GitHub repo in the description

below all of the raw code for the samples in this course are hosted there it won't be quite a streamline of an

option but it is an option now you should also know that this course is just one part of the full back-end

developer career path over on boot. so if you're interested in going from zero to hired as a backend developer you

should definitely check that out too now as long as we're talking about external resources know that if you get stuck

during this course you have some options for help first you've got the boot. deev Discord second you've got the free code

Camp Discord and third you've got the free code Camp Forum I will link all of those down in the description below okay

one last thing before we jump into the course if you want to connect with me personally or you want access to my

other go and backend content then you can follow me on Twitter wag lane or you can subscribe to my YouTube channel at

boot. I'll link both of those down in the description below with all of that out of the way let's talk about go

everyone always wants to talk about how fast the go programming language is let's talk about it and let's compare go

to some of the other more popular programming languages so in terms of execution speed

execution speed go is much faster than JavaScript python Ruby and PHP pretty much any

interpreted language a language that's not compiled is going to be slower than go because go is a compiled language now

don't worry too much if you're not familiar with the terms compiled and interpreted we'll talk about those in

just a minute for now just understand that go is much faster um than these languages when it comes to executing

programs if we're doing computationally heavy work go is going to be much more performant um than some of these other

languages now here on the other side I've listed some compiled languages so when it comes to compilation

speed compilation speed go is actually much faster than these compiled languages when it comes

to compiling the code now again we'll talk about compiling in a minute but for now just understand that you have to

compile your code before you can can run it when you're working with a compiled language and so by having a fast

compilation speed like go has it actually increases developer productivity quite a bit we can iterate

more quickly on our code we can deploy it more quickly it's not as expensive to run tests to compile uh the program and

deploy it to production um so this is actually a huge benefit that go has now I do want to point out that go does not

necessarily run faster it does not necessarily have a faster execution speed than all of these languages but it

does beat them handily when it comes to compiling not to beat a dead horse but I want to talk a little bit more about

execution speed so we talked about how go is generally faster than the interpreted languages right python

JavaScript Ruby PHP and so on it gets a little interesting when we compare go to kind of the natively compiled languages

or the languages that compile directly to uh kind of machine code that runs on your CPU versus the compiled languages

that run on top of a virtual machine right so the the two big ones that run on a virtual machine are Java and C

while some of the compiled or natively compiled languages that you'll be familiar with might be rust C C++ even

though go is a natively compiled language a language that compiles directly to machine code like rust C and

C++ its execution speed is actually more similar to Java and C when it comes to its runtime speed how many computations

it can do kind of per second and we'll talk more about this later but the primary reason for that is the go run

time there's basically a chunk of code that's included in every go program that manages memory and that tends to slow

down the execution speed a little bit that said it is worth pointing out that a go program tends to use much less

memory than Java and csharp because there isn't a need for an entire virtual machine here we are the first coding

challenge let me break down what we are supposed to do and then I'll kind of explain what this code over on the right

actually does so um our assignment is to log the string starting textio server to the console instead of hello world so

throughout this course we'll be building out little pieces of the textio product which if you're familiar with twilio

it'll kind of be like a twilio clone it's a kind of backend server that sends SMS and email messages and works a lot

with kind of text textual data every file of go code has a package declaration at the top here we have

package main simply because this program builds into an executable go program right so we can run this code kind of

Standalone the next line is importing the fmt package from the standard Library we are importing it because

we're using it down here within the main function now the main function is the entry point to the program so every go

program starts exec ution at the top of the main function which is just a function named main that takes no inputs

and doesn't return anything on line six and seven we have some single line comments these don't execute they are

not part of the program they're just there for documentation and single line comments just start with that double

slack finally on line eight we have the one thing that this program actually does which is print the string hello

world to the console so let me go ahead and run that see down here it printed to the

console it's using the stand libraries fmt package um and the print line function that is exposed from that

package uh to do so so the assignment here is pretty simple uh we're just supposed to swap out that hello world

message for starting Tex iio server going to run that and make sure it looks like what I would

expect we're good to go next let's fix a quick bug I love quick wins um we're not going to talk about all of this syntax

in this program what we're interested in is just fixing the math bug on line 17 so the assignment description says texo

users are reporting that we're billing them for wildly inaccurate amounts they're supposed to be build

for2 for each text message they send something else is happening so the total cost here is being set to the cost

per message plus the number of messages now that doesn't make a lot of sense to me go ahead and pause the video see if

you can figure this one out on your own um to me it looks like the cost per message should be multiplied by the

number of messages right and let me let me run it like this so that we can see Doris spent 4.02 on text messages

today four messages that doesn't make sense right for four messages she should not be

build $42 if each message only cost 2 cents so I'm going to go ahead and change that to multiply I would expect 8

cents yep Dora spent 8 cents on text messages today cool going to go ahead and submit that this is one of my

favorite XKCD Comics uh you can pause and read it uh really quick if you'd like slow and resource expensive

compilation times a really terrible thing to work with I've worked on systems in Java and C++ that took over

an hour to compile the code that means that if we find a bug and we want to deploy it to production even if we get

the bug fixed within five minutes it's still going to take an hour just to build the new production version so that

we can deploy it on our servers I've personally never worked on a go program that's taken more than just a couple of

seconds to build and compile so the first question is go code generally runs blank than interpreted languages and

compiles blank than other compiled languages like C and rust so the answer is going to be faster and faster right

it runs faster than inter most interpreted languages and it compil Iles faster than most compiled

languages so the question on this one is does go generally execute faster than rust the answer is going to be no so

I've thrown around this word compilation or compiled a few times but we haven't really talked about what it means when

we write code we write it in a human readable format right typically in a file in the

case of go A.O file right maybe main.go and this file is going to contain human readable text right go code that

we as developers work on the thing is your computer's Hardware doesn't know what any of that human readable text

means your computer's CPU only understands binary right which is ones and

zeros right which at the end of the day is just numbers right but it's just numbers and simple operations things

like add and subtract so we need some process that we can use to convert human readable code to machine code that can

be executed by the computer's hardware and that's all that compilation is compilation is just the process of

taking some human readable code right go code in our instance and converting it to Binary or machine code that our

computer can actually understand so what does this process actually look like Well normally you'd start by writing

your go program so say main.go and you'd run it through the go compiler on your command line you'd type go

build and that would produce a new file which is the executable program let's say we're doing a hello word a hello

world program it might be hello world.exe

right an executable program on your computer and you could run that executable directly on your operating

system without ever having to use the go tool chain again so the great thing is you can take this hello world.exe

program and give it to someone else and they can run it on their computer without ever having to install the go

tool chain or even know that you used go to build the program in the first place this is different than languages like

python where if you want to run someone's python code you have to use the python interpreter every single time

time and you run the source code you run the source code directly on your machine it's also worth pointing out that part

of the reason that compiling is so much faster at runtime is that we do all of this compiling work upfront so when we

go to run the executable we don't have to do any conversions from Human readable text to Binary machine code

that's different than how interpreted languages work with an interpreted language as we run the program The

Interpreter is reading the human code and kind of at runtime converting it to machine code that the CPU can operate on

so you might be wondering where is the compiling Happening Here on botev well we actually do the compiling and the

running at the same time for you so when you click the Run button um we're actually taking your code shipping it

off to our servers compiling it running it and giving you the result don't worry when we get down the road to the actual

project you'll be building and running your own go code on your own machine but we can see the difference between a

compiler error and a runtime error even here on Bev so for example um here in this code the assignment says to pass

this exercise fix the compiler error in the code so I'm just going to run it as is and you'll see we get this nasty

error here and it says main.go right line six syntax error this is actually a compile time error so we weren't even

able to compile this code it didn't fail at runtime it failed compile time right which again that distinction will become

more clear a little bit later so anyways um we can fix it by adding that Clos parentheses that was

missing and now it compiles and runs just fine so to review go code like this

little go program here that prints hello world that's not understood directly by the hardware on your computer your

computer's processor or your computer's CPU understands machine codee so we need to

take our human readable go code run it through the go compiler to produce the machine code that we can run directly on

our CPU right the CPU is designed by the manufacturer to run a specific format of binary cool so the question for this

exercise is do computer processors understand English instructions like open the

browser no processors are not chat GPT uh they need machine code now we touched on this very briefly

before but I want to talk about how you distribute a compiled program versus how you would distribute an interpreted

program so let's say that you'd written a script in Python so you've got this script main.py right this is raw python

code and you want to give it to your friend so that they can run your script well all you would do with an

interpreted language is give your friend the main.py file and then on their computer they would run the command

Python main.py and they'd be able to run your code now there are a couple of downsides

to this approach the first problem is that your friend needs to have python installed on their computer so your your

friend being able to use your program is dependent on them already having python installed it's even dependent on them

knowing how to use it or knowing how to use a command line right so Distributing the programs of interpreted languages

can be tricky because it's really only useful if you're Distributing to other developers who know how to use these

tools already the other problem is the code itself let's say you spent you know many weeks writing this python script

and it's super useful and you're trying to sell it to customers if you just give them your python code I mean they

effectively own it they can change it even if you didn't intend for it be open source congratulations it's now open

source the problem is you can't really allow someone to use your program without giving them all of the Special

Sauce that makes it work let's review how this works in a language like go so in go we'd start the same way right we'd

write some human readable go code in a file called main.go but instead of giving that file to our friend we're

going to compile it first going to compile it we'd use the go go tool chain so we'd

write something like go build in our command line and that would produce a new executable file right so this is

this is machine code here um let's just say that the name of our program is Hello World why

not so if we're on Windows it might be hello world.exe right so when you go online and you

download a program to use say it's a video game um it is probably a bundle of machine code it is a built

binary right in order to run your favorite video game let's say Starcraft 2 or World of Warcraft you don't need to

install the C++ compiler right you're just given the built kind of final product the final executable program and

that's what we're doing in uh the go programming language as well so now we can give our friend this

executable they don't need to install go and they do not need access to the original source code so generally

speaking Distributing programs that are natively compiled is much much easier um than Distributing programs that kind of

have a runtime dependency like an interpreter so to answer the question for this exercise do users of compiled

programs need access to the source code no they don't and a related question which language is interpreted we've got

go C++ Python and rust and the answer is python the rest are all compiled so now the question is why is it generally more

simple to deploy a compiled serers side program or backend application and the answers are compiled code is more memory

efficient because Docker exists there are no runtime language dependencies or because compiled code is

faster well it's just the same as what we talked about earlier um when we deploy to a server say on the cloud uh

we have to have all of the dependencies uh that our backend application needs in order to run installed on that server

and if there are no runtime dependencies if all we need is a compiled binary then that's arguably the simplest way to do

it right so the answer is it's more simple to deploy a comp to deploy a compiled program to a back-end server if

there are no runtime language dependencies things like the python interpreter or The nodejs Interpreter

for example go is strongly typed and statically typed and that's a really good thing if you've been paying any

attention at all to the JavaScript World you'll notice that a lot of JavaScript developers are making the switch to

typescript and that's primarily to get access to static typing a lot goes into typing and type systems but one of the

biggest benefits of a static type system like goes is that when we declare a string right like say this username

string that I've set equal to wag Lane we can't later accidentally change it to an integer a number right like a float

64 um it's going to stay a string the nice thing about a static type system like we have with go or that you have

with typescript is that we get feedback on our errors uh much more quickly right rather than finding out about a bug when

our code is running in production we find out about the bug say when we compile our code let's move on to the

assignment the the assignment says we'll be using basic authentication for the text iio API so basic authentication is

is just this format here where you've got a username and a password um in an HTTP header it tells the server on each

individual request to the server who you are right it's kind of like logging in um or rather it's kind of like being

logged in okay uh so the code on the right has a type error change the type of password to a string Okay cool so I'm

just going to run it to see the type error first so invalid operation username plus colon plus password has

mismatch types of string and int now this is a compile time error we we weren't even able to compile this code

right let alone run it in production um so we've been instructed in the assignment change the type of password

to a string but use the same numeric value so that it can be concatenated with the username variable Okay cool so

I'm just going to change this to a string by surrounding in double quotes that's how you do strings and go

pretty similar to other languages and then I'm just going to change that type to a string type and run it again

authorization basic wag Lane colon number that looks good to me when we're talking about the

performance of a programming language or an application we really care about how it performs across two different axes

one is speed how fast it can do computations right which is kind of measured in CPU cycles and then we also

have memory consumption which is just how bloaty the program is how much data it has to store in memory to be able to

do those computations every program you write no matter the language is going to be using memory every time you create a

new variable it allocates space in memory where it can store that variable's data now in languages like

rust or C memory management is effectively manual now that said Russ does have some nice tooling that kind of

takes care of it for you at compile time so it's not quite as error prone um as as it would be in C or C++ but at the

end of the day your program is allocating memory right it's saying this chunk of memory I'm going to use I'm

going to store some variable data here in this bit of RAM and then later your program says I'm not using it anymore um

so we can free it up for use by other programs now let's jump over to Java so with Java it's a little bit different um

Java is a garbage CL CED language garbage collection which essentially means that memory management is

automated and in Java it's done by the Java virtual machine so every time you run a Java program you're actually

creating an entire mini virtual machine that your Java bite code runs

within so this is the jvm and then you kind of insert your code

into the jvm and you run your code in there and the jvm is what takes care of allocating

and freeing all of the memory that you use and this creates overhead basically at the end of the day Java programs use

quite a bit more memory than rust or C programs go is in an interesting sort of in between world where go is a garbage

collected language like Java so it has automated automated memory management but it does not have a jvm when you

compile go code rather than having to run it within a jvm just like with Rus and C you get one binary or one

executable program the difference is that go includes a runtime a

runtime within every single binary that's built using the go programming language so we could think of it as

something like this it's kind of like a little side car that is compiled

alongside your code so your go program basically has this this little bit of extra code that's added to it and that

bit of code is what handles garbage collection and automated memory management so it's a little more bloaty

than what you'd get with rust and C right it is garbage collected um but it's not nearly as um expensive in terms

of memory overhead as a language like Java or C let's take a look at what some actual numbers look like I pulled this

chart from Dexter darwick uh blog and if you're following Along on botev you can click the link to go check out the full

the full blog and the description of this experiment but basically he built a restful web server in three different

programming languages right in Java go and rust and then me measured the memory consumption and when the servers were

just at rest effectively doing nothing and waiting for requests to come in Rust used less than half of the memory that

go was using and go used 100 times less memory right measured in megabytes than the jvm was using to run the rest

service so to order the three languages in terms of memory efficiency I would say Java is the least efficient uh go is

in the middle and rust would be the most memory efficient and it's also worth pointing out just really quickly that as

the load on the server increases I would expect go to have more similar performance to Java in other words we

wouldn't see as quite a large discrepancy here right go would likely still be more memory efficient than Java

almost certainly in fact um but it probably wouldn't be a 100x discrepancy we're seeing this huge discrepancy um

mostly because this is an idol uh a test of an idle program so generally speaking which language uses more memory that's

going to be Java another question on the same topic is what's one of the purposes of the go runtime so to style go code

and make it easier to read that doesn't make sense that would be like compile time tooling right not run time tooling

to clean up unused memory to cook fried chicken or to compile go- code so it's definitely going to be to clean up

unused memory and if you remember remember the runtime is just that little bit of extra code that's included in

every compiled go program that among other things handles memory management so we've already talked about

how go has strong and static types but we haven't yet talked about what those types are you're probably already

familiar with Boolean values and string values which are valid go types and also exist in pretty much every other

programming language um numbers are where it first starts to get a little bit different uh if go is your first

compiled programming language generally speaking numbers fall into four different buckets we have integers

unsigned integers or uints floats and complex numbers integers are just whole numbers they can be positive or negative

right 1 2 3 4 you get the idea unsigned integers are the same as integers but they're not signed which basically just

means they don't have a negative component you can only represent positive numbers in in an unsigned

integer you probably already familiar with the idea of floats it's just fractional numbers right numbers that

have a fractional component things like 1.21 or 3.14 complex numbers are a little funny

they're used to represent the concept of imaginary numbers if you've gotten to imaginary numbers in your math studies

I've never actually used complex numbers um in production I'm sure there are plenty of use cases for them but we're

not going to go into detail on how they work here you can certainly go read up on it if you'd like the only other thing

worth mentioning is that size matters when it comes to types A uint 8 and a uint 16 are two different types they

both represent unsigned integers but a u 16 has twice as much room for data within it it has 16 bits of data whereas

a u 8 only has eight bits for example the largest number that you can store in a uint 8 is 255 because that's the

largest number you can represent with eight 1es and zeros in binary but with a uint 16 the largest number you can store

is about 65,000 again because that's the biggest number that can be represented by 16

binary digits just like bigger number better person uh bigger number in your types means you can represent more

possible values uh within that type so float 64 can represent more values than a float 32 the only reason you wouldn't

use a larger type is if you're trying to save on memory if you're trying to write a program that is hyper performant

you'll want to use a smaller size right if you know that an integer is only ever going to store three different values

say 1 two or three then you might consider using a u and 8 the bite type is an interesting one and it's one that

you'll use a lot especially when you're say marshalling a Json object um to be sent across a network connection or

maybe you're reading to and from a file on disk um but under the hood a bite is just an Alias for the uint8 type which

makes sense right a bite is just eight binary digits eight bits and that's all a uint 8 is a rune is a Unicode code

point which generally speaking you can think of as one character in a string and that's usually how it's used under

the hood it's just an alias for the int32 type moving on to the assignment it says initialize the given variables

to int float 64 bu and string respectively with their zero values and um as we can see here if we just use VAR

the name of the variable and the type that should do it so we'll initialize the variables here so

VAR SMS sending limit is an INT VAR cost per SMS is a float 64

has as permission is a and username

is a string okay cool and all so all of these variables are now instantiated and should contain their zero value so for

example zero uh 0.0 false and empty string so let's go ahead and run that and that looks correct to me I'm

going to go ahead and submit it we've been declaring variables the hard way now we're going to do it the easy way

there is an operator in go colon equals that is the short assignment operator and it allows us to to declare variables

and have go infer their type so instead of typing VAR empty string we can just say empty colon equals the empty string

and go knows that this has to be a string so it is a string now when we use this short assignment operator we're not

saying this is a loose type that can change in the future it's still a static type empty is a string just like it

would be if we declared it this way in reality in go you will very rarely see variables declared like this you will

almost always see them declared using the short the short assignment operator for example num Carson equals 10 creates

a new variable called num cars and sets it equal to 10 and its type will be inferred to be an INT and the int type

Alias is either int32 or int64 depending on your computer's architecture if you want to specify a particular size of

integer then you would declare it using this kind of lonand syntax so in this assignment we're just meant to declare a

variable named congrats with the value happy birthday using a short variable declaration so as simple as congrats

colon equals the string happy birthday let me run that

perfect this next assignment says our current price to send a text message in texo is 2 cents however it's likely in

the future that the price will have to be a fraction of a penny or have a fractional part to the cost so we should

use a float 64 to store this value edit the pennies per text declaration so that it's inferred by the compiler to be a

float 64 Okay cool so here we're just setting it equal to two if I run that then I get the type of

pennies per text is int and this percent T in go um is is a formatting verb that that tells the go programming language

or or at least the print F function I should say the formatting package from the standard Library um that I want to

print the type of this variable rather than its value so that's why we're saying int there instead of

two um to get a float all we need to do is change it from two to 2.0 I believe 64

cool another handy syntactic Quirk of the go programming language is that we can declare multiple values on the same

line so in this assignment it says declare a float called average open rate and a string called display message on

the same line okay so average open rate display message same line the average open rate

um must be23 and the display message should be the

string is the average open rate of your message and then it looks like this is just going to print them

together so it's going to say 0.23 is the average open rate okay cool let's go ahead and run

that 023 is the average open rate of your messages that looks correct to me so we've already briefly talked about

the different type sizes in go right so we have the int type int 8 int 16 int 32 and int 64 and it's important to

understand that the int type just aliases int32 or int64 um same with the uint type just depending on your cpu's

architecture so you might be on a 32 or a 64-bit machine most modern machines are going to be 64 bits my

recommendation is that unless you have an explicit reason to care about the size right so unless you're trying to

kind of hyper optimize for performance then you should really just stick to these four types int uint float 64 and

again if you're working with imaginary numbers then complex 128 but that's honestly unlikely so so these three

types are going to do the vast majority of the heavy lifting when it comes to working with numbers in go we can also

convert numbers between you know different number types for example we could take a an integer 88 and convert

it to a float like this so it become 88.0 right um converting the other way is a little trickier though because say

we had 88.6 if we were to convert it to an INT we would lose the point 6 we would truncate it down to just 88 now

this assignment says our text AO customers want to know how long they've had accounts with us follow the

instructions in the comment provided you will create a new variable called account age int that will be the

truncated integer version of account age Okay cool so create a new account age int here should be the result of casting

account age to an integer so we'll just do int account age and I would expect that to be two after casting it because

it should truncate the 6 so let's go ahead and run that your account has existed for 2 years yeah that looks good

to me we already briefly touched on this but it's worth mentioning again I

recommend that you stick to the I call them the default types so for example we know there's um you know five or six I

can't think of it off the top of my head now different types of inss right int int 8 int 16 in 32 int 64 I'd recommend

sticking to int unless you have a very good reason to specify a smaller size like int 8 or in32 and that's simply so

you avoid cluttering your code with tons of type conversions that can sometimes even lead to bugs so unless you need a

smaller type for performance reasons just use these default types okay so the question for this assignment is when

should you elect to not use a default type when either a default or a specific size will work when my system has lots

of extra Hardware that I want to utilize or when performance and memory are primary concern so it's going to be

performance if you have performance concerns that's the time I would maybe stray away from the default

types the next question is what does the size of a type indicate so a float 64 what does 64 mean is it bits bites or

nibbles uh the answer is going to be bits now it is worth pointing out nibbles is a real thing so a bite is 8

Bits a nibble is actually Four bits if you didn't know that fun interesting trivia aside from variables go also

supports constants which are immutable values um and in go just like in JavaScript or typescript we use the

const keyword and constants do not support the short declaration syntax so we have to kind of write it all

out okay so getting to the assignment says use two separate constants something weird is happening in this

code what should be happening is that we create two separate constants Premium plan name and basic plan name right now

looks like we're trying to overwrite one of them okay cool so on line six we've got Premium plan name and we're setting

it to Premium plan and then we have Premium plan name again attempting to override the value and set it to a new

string if we try to run this we actually get a compile time error so we're not allowed to mutate constants in go so

what we should be doing is creating a separate constant and it should be named basic plan name let's go ahead and run

that plan Premium plan plan basic plan looks good to me constants in go are not the same as constants in JavaScript and

in typescript in JavaScript and typescript the const keyword really just means you can't reassign to this

variable but you can compute the variable or the variable's value at runtime in go every value

that's stored in a constant must be known or computed at compile time before the program runs so if we create this

new constant called my int and set it equal to 15 within the compiled go binary effectively this symbol my in

just refers to the static number 15 the cool thing is that we can actually compute constants like we can

make constants that depend on other constants but that computation will run when we compile our code not when we run

our code so for example um I can create this constant first name Lane last name Wagner and then I can create a new

constant called full name it's first name plus a space plus and the last name and that's really convenient in case I

ever want to change first name uh now I don't have to change it in two places right full name will automatically

update but this is only valid because all of the inputs to this full name constant first name and last name are

known at compile time so the compiler can still do the thing it wants to do which is replace full name with a static

string right lane space Wagner so on to the assignment says keeping track of time in a message

sending application like textio is critical imagine getting at a point reminder an hour after your doctor's

visit not very helpful right complete the code using a computed constant to print the number of seconds in an hour

okay so we've got the number of seconds in a minute is 60 the number of minutes in an hour is also 60 so how many

seconds are in an hour cool well we could hardcode this as like 60 * 60 but the cool thing is we can actually

compute it because we can say well we know the minutes the number of minutes in an hour and we know the number of

seconds in a minute and if we multiply those two together we should get the number of

seconds in an hour right that looks correct to me so I'm obviously a huge go fan but

formatting strings in go is honestly one of my least favorite features of the language I think it's one of its

weaknesses at the moment who knows maybe it'll improve in the future the way it's done well we essentially have two

different functions provided to us by the standard Library we have print F and S printf printf prints a formatted

string directly to standard out and S printf just Returns the formatted string as a value basically all string

formatting in go currently works the same way we have these formatting verbs things like percent V percent s percent

D and they're replaced in the string template with actual values so for example I am percent V years old the

percent V in this case is replaced by 10 the first parameter uh that comes after the template in the print F function

here we could also replace with a string instead of an integer right I am percent V years old way too many for I am way

too many years old percent V is sort of the default formatter it's usually what you want assume you don't want to print

in kind of the default standard way using percent V then there are a few others um percent S interpolates A

String percent D interpolates an integer in decimal form so for example 10 becomes the number 10 instead of say in

binary form uh percent s is for floats so you can specify the number of kind of places after the decimal point uh that

you want printed out to the console or printed out to The Returned string in the case of s printf um so I actually do

end up using percent F fairly regularly when I'm working with floats so onto the assignment it says create a new variable

called MSG online 9 MSG stands for message of course um it's a string that contains the following High name your

open rate is open rate percent where name is the given name and open rate is the open rate rounded to the nearest

10's place okay so the 10's place is the number right after the decimal so let's get started here message colon equals

fmt dos printf so we're going to use S printf instead of print F because we don't want this value going to standard

out we want it returned from the function so we can save it in the MSG variable

let's just grab this template so we'll use percent s we could use percent s or percent V here because

we're just uh interpolating a string and we'll do percent um .1 F because we want to just print the

first number after the the decimal point right the tenth place okay and then we just pass the two

values as the following parameters or as the last two parameters so name and open rate right so the first value name will

go into the first verb the second value will go into the second verb let's run that see what we get hi s Goodman your

open rate is 30.5% that looks good to me let's talk about conditionals in go so a

conditional is just where we are checking if a condition is true if it is we do one thing if it's not we may do

another so for example uh here's an if statement in go and if this expression evaluates to true then we'll run the

stuff within the curly braces the body of the estatement if you're familiar with other programming languages like

JavaScript this is um a very very similar syntax the only difference is we're not surrounding the height is

greater than four section with um parentheses so again to be clear this bit between the if keyword and the curly

brace um will be evaluated and if it evaluates to true then the stuff inside the curly braces will be executed um so

in this case we have the variable height and we're using the greater than operator um to compare it to the number

four so if height is greater than four then we'll print you are tall enough sort of listed um some of the different

comparison operators uh down here at the bottom they are basically identical to pretty much every other programming

language you will uh probably have used uh up to this point additionally we can do different things um if the if

statement does not evaluate to true so this is a perfectly valid if statement you do not need an else if or an else

block they are they're optional effectively um but the way it works is when we get to this code uh basically

we'll we'll uh compare height to six right and if that expression evaluates to true then we'll just print you are

super tall and we'll be done okay otherwise if that expression evaluates to false then we'll drop down

into this next if else or sorry else if statement and we'll compare height to four if height is greater than four then

we'll print you are tall enough and again we'll be done at that point so if this evaluates to true we execute this

um kind of section of code between the curly braces and at that point we'll be done otherwise if that's also false so

if height is not great than six and height is not greater than four then the else statement executes notice the else

statement does not have its own expression it just kind of always executes if all of the if and else if

statements um turned out to be false so let's jump into the assignment it says fix the bug on line 12 the if statement

should print message sent if the message length is less than or equal to the max message length or message not sent

otherwise Okay cool so up here we've defined two variables uh message length is 10 Max message length is 20 um and

then here we're going to do some comparing let me just run the code in its current

state says trying to send a message of length 10 and a max length of 20 message not sent okay so that seems problematic

right because with a message length of 10 and a Max message length of 20 I should be able to send that message so

the Bug Online 12 I think we just need to flip this operator to be less than or equal to so that now this expression

right message length less than or equal to Max message length should evaluate to true because it is message length is in

fact smaller okay let's run that message sent that seems to work it's worth pointing out that in go we

also have kind of an alternate way to write if statements if the variable that we are

comparing in an if statement is only used in that if statement then this syntax can be helpful okay so here's

kind of the traditional way of doing something we would create a variable called length let's just assume it's an

integer you can kind of forget um this function Syntax for now we'll talk about it um in a future chapter but basically

the idea here is we have a length variable it's an integer right and we're initializing it here we're creating the

variable here um and then we're compar pairing it against one right we're checking if it's less than one and if it

is we're doing something in this case we're printing that the email is invalid well instead of this syntax and by the

way this works perfectly fine there's nothing wrong with doing it this way um but we can alternately do it this way

which is basically to initialize that length variable in the if block within that first kind of initial statement so

notice there's two statements here um separated by a semicolon and in the first one we're

creating that length variable and then then we're moving the comparison itself kind of after the semicolon and then if

that condition obviously evaluates to true then we'll um execute the block this does kind of two things for us

first it saves us a line of code um which I would argue probably isn't the biggest benefit in the world um but more

importantly uh it makes it so that this length variable is only accessible within uh kind of the scope of this if

block so kind of down under Neath this code we wouldn't be able to use the length uh variable anymore which is kind

of nice if you never intended to use it in the first place you can kind of think of this as a clean code hack or like a

um kind of safety hack um to ensure that the length variable is never reused Down Below in other code when you never

intended it to be reused okay so uh the question for this assignment is why would you use the initial section of an

if statement uh and the answers are to confuse other programmers to keep the code concise and the scope limited or to

speed up your code um the answer is going to be to keep the code more concise and to again limit the scope

that that variable um exists within like other programming languages go supports functions functions are basically just a

way to break up your code into individual units that are easier to reason about right a function takes in a

specified number of inputs and it returns ears a specified number of outputs for example this subtract

function here named sub takes two inputs X and integer and Y an integer and it returns a single integer in this case it

just performs the simple calculation x - Y and then Returns the result to the CER now this little bit right here right

Funk sub X integer y integer returns integer is what's known as the function signature if you've never heard that

term before it's basically just a description of what the function does in terms of its types in terms of its

inputs and its outputs and what types they are right this basically says this is a function called sub it takes an

integer X and an integer Y and returns another integer function signatures are great because they tell us how we can

use the functions really at the end of the day if we're the person calling the function or the person using the

function really all we care about is what we need to give the function as input and what we get out of the

function in terms of its outputs so a function signature basically tells us all we need to know about a function to

be able to use it it omits all of the implementation details the stuff with within the curly brackets or within the

body of the function so let's get on to the assignment assignment says we often need to manipulate strings in our

messaging app that makes sense right we're working with SMS and email uh messages within textio so we're doing a

lot of textual data manipulation the concat function should take two strings as inputs and smash them together right

so returning a new string that is a concatenation of the inputs for example hello Plus World equals hello world so

we'd expect to return this concatenated string from our concat function over here fix the function the function

signature of concat to reflect its Behavior Okay cool so let me try running this and just see what happens looks

like undefined S1 undefined S2 undefined S1 okay so these are

undefined and so S1 and S2 that kind of stands for string one string two that makes sense

the problem here is that we're not we're not telling go what the types of the inputs should

be and this plus operator when operating on strings just concatenates so that should work let's go ahead and run

that yeah this looks good to me I want to just make one more point about function signatures in go you'll notice

that the type comes after the name of the variable so S1 is a string S2 is a string and that's just

to make it a little easier to read the authors of the go programming language kind of built on uh a lot of the ideas

from C and in C it was the reverse it was string S1 string S2 and that just kind of reads a little clunky if you're

used to kind of speaking in plain English makes more sense for the type to kind of come after um what it describes

go provides another bit of interesting syntactic sugar when it comes to function signatures when multiple

arguments are of the same type in this case X and Y the inputs to the add function are both integers um the type

only needs to be declared on the last one assuming that they're in order right so in this case this is valid go code

and X and Y are both integers because they follow one another we can put the integer um just after the y if we were

going to add say a string as a third parameter uh to this function then we would just add a comma here after int

and put you know name String or or whatever um this is just a bit of syntactic sugar uh it makes our code a

little less verbose you don't need to do this you can explicitly put the type on every input and output but you will

often see code like this it's a convenient shorthand so we've got these two um example Snippets of code Funk

create user first name String last name String age in and Funk create user first name last name String agent so which of

the following is the most succinct way to write a function signature Su synct is just another word for kind of it's I

guess it's the opposite of verbose right fewer fewer words um it's going to be the one that

uses the syntactic sugar which is this one because we're omitting the string keyword after first name so we already

talked about this briefly the idea that in go we specify the type of of a variable after the variable name and

this is you know different from kind of the C style way of doing things which if you were to declare a variable Y and C

you would say int Y and really the authors of the go programming language just felt that that didn't flow

naturally from English it's not the way we talk right we say x is an integer not integer is X if you want to read up on

that decision and why they ended up uh choosing that style then you can follow this link here assuming you're following

Along on botev so the question is what are we talking about when we discuss this declaration syntax right this this

swapping of the name and the type um and here are options the decision about Campbell case versus snake case um the

style of language used to create new variables types and functions guard Clauses versus if else no the ever

important question of tabs versus spaces no it's going to be the style of language used to create new variables

types and functions related question is Which languages declaration syntax reads like English from right to left C or go

the answer is going to be go go supports functions as data or basically the idea that you can pass functions around your

program uh to be called in different places callbacks right if you're familiar with JavaScript then you're

probably familiar with the idea of a callback it's a function that you could pass to another function to be called

later this question deals with that idea whenever we pass a call back in go the type of the function Chang based on what

its inputs and outputs are so for example here funk in in int is a function that takes two integers as an

input and returns an integer and that's going to be a different type than a function that say took three integers as

input and returned an integer and if you think about it it makes sense right if I'm going to pass a function to another

function so that it can call it later it kind of needs to know how many inputs how many parameters it can pass into

that function if it's a function that takes two inputs versus three inputs then the caller is going to have to

write the code differently so we have to treat every function signature as its own unique type so this question is a

bit of a doozy I encourage you to pause the video and try to work this one out on your own um but basically it says

what is this hairy beast here right F Funk Funk int int int int int all right potential answers are a

function named F that takes as int takes an INT as the argument and returns an INT uh no it is not nearly that simple

right a function named F that takes a function and an INT as arguments and returns a function let's

see uh that right there is a full function and an INT as arguments and returns a function no this returns an

INT okay a function named f that takes a function and an INT as arguments and returns an INT that's what I believe it

will be function named F that takes a function as the argument and returns an INT yep that's not it so ju to be clear

f is a function it takes two parameters a function right a function of a specific

type a function that takes two ins and returns an INT and as its second parameter an INT and then F returns an

INT hopefully that makes sense again feel free to pause the video and and stare at

that for a second let's talk a little bit about memory and how data that we create in our program using variables is

stored in memory so over here I'll keep track of the memory of our program and over here I'll write some

code so let's say in our code we write X colon equals 5 right so we're creating a new variable called X and we are giving

it the value the integer value of five and then we're placing the value five in that memory right stored as

binary data within Ram now in our program X the symbol is essentially just a

pointer it points to this location in memory so let's say on the next line of code we update X and we say x equal 2 so

now we're reassigning the value of x to two now let's try something different what if we create a new variable called

Y and we initialize it to the current value of x which in this case happens to be two well in this

case we're actually going to allocate a new section of memory to store the value of y and we'll initialize it to the

current value of x which is two and the symbol y now has its own location in memory so

we basically created a copy of X now this idea is really important to understand because sometimes in

programming we'll have multiple variables that actually point to the same location in memory they can

overwrite each other and sometimes we don't sometimes we have copies of data right so now for example if I were to

update y let's say I made y equal 1 at this point x would be unaffected X would remain two but y now becomes one right

because we have a copy these two variables X and Y reference different locations in memory so why does all of

this matter well in go variables are passed by value not by reference so let's take a look at this code snippet

here top of main we deare a new variable called X we set it equal to 5 and then we pass X into a function called

increment the increment function just adds one to X right making it six after that we print X and the weird thing is

that when we print X here we still get five and the reason for that is the increment function was operating on a

copy of X when we pass X in here to increment increment gets a new copy of X still equal to 5 it increments that X to

6 and then because we are not returning it it essentially just gets thrown away and then back in main we still have this

same X that's still equal to five the correct thing to do here would be to have the increment function return X

after making its modification and up in main we would write x equals increment X so that we could capture the return

value from the increment function so moving on to the assignment it says it's critical in texo that we keep track of

how many SMS messages we have sent on behalf of our clients fix the bug to accurately track the number of SMS

messages sent okay let me just try running this in its current state and we're missing a

return okay I'm going to remove this this uh type return there and see what happens sent 430

messages and it looks like here we have sends so far sends to add increment S is doing nothing because s so far is still

printing as 430 okay I think I'm understanding so let me put that back in the assignment

says alter increment sends so that it Returns the result after incrementing sends so

far alter the main function to capture the return value from increment sends and overwrite the previous sends so far

value Okay cool so this is pretty similar to the code snippet here basically we need to return an INT so

we're going to return send so far and then here we need to reassign

sense so far into the result of increment sense cool so again here we'll still be operating

on copies but because we're going to return the copy and save it back into the original variable we should be good

to go let me run that yep you've sent 455 messages that looks correct functions in go can have

multiple return values and when they do have multiple return values the Syntax for specifying that is just to wrap the

return values in parentheses as well so when there's just a single return value we do not wrap that return value in

parenthesis but when there are multiples we do wrap them in parenthesis one thing I really like about go is that it does

not allow you to have unused variables and because it doesn't allow you to have unused variables and because it allows

you to have multiple return values from a function we kind of need a way to ignore some of the return values because

there are definitely instances where a function returns two things but maybe we only care about one of those things for

example a point on a graph can be described by its XY coordinates but maybe all we care about is the x

coordinate so here we can call the get Point function and ignore the Y value by using an underscore and it's important

to understand that the underscore is not just like a conventional name that we're going to ignore it's actually ignored

the compiler completely removes it from our code so moving on to the assignment here

in texo we have obviously first names and last names for all of the users that we're able to send messages to well when

we welcome someone to texo we don't need their last name so let me go ahead and try to run this code and you'll see

we'll actually get a compiler error that says last name declared and not used used like I said go does not allow us to

have unused variables which I think is kind of an awesome uh little bit of the tooling it helps keep our code very

clean and concise easy to understand um so we need to explicitly ignore that last name with an underscore if we're

not going to use it let me try running that again and that looks good to me in go we can name our return values and if

we do it actually Alters the behavior of the function just a little bit let's take a look at

this function get chords or get coordinates it returns two integers and we've named the integers X and Y and by

naming them we've actually initialized at the top of the function the the variables X and Y and they're

initialized with their zero values so in the case of an integer literally just the number zero for both of them the

other interesting thing about naming our return values is that if we use a naked return statement a return statement that

doesn't explicitly say for example return 0 comma 5 then the values of X and Y are automatically returned from

the function so this version of get coordinates is actually the exact same as this kind of

more verbose version of get coordinates right here we have not given the return values the names X and Y and instead

we've initialized X and Y to their zero values and then returned them explicitly now a couple of recommendations I would

recommend using named returns when you want to document kind of what the intended purpose of each return value is

so for example if you have a function that just returns three integers that function signature could be pretty

confusing but if you have a function signature that says it returns three integers and they're named width height

and length that's a lot more interesting to the caller of the function they understand the purpose of each

individual return value much better so I like to think of named return values as basically a built-in way of documenting

what the purpose of all of your return values are and you should generally just use them on the other hand this implicit

or automatic return that you get along with um named return values I would typically advise against you'd only want

to use this in like very short very simple functions um because it harms readability right and I'm pulling this

directly from the tour of go they also agree with me um implicit returns or naked return statements um generally a

little bit harder to understand so the way I would write this function personally would be get chords XY in and

then I would explicitly return X and Y so let's jump down into the assignment it says one of our clients likes us to

send text messages reminding users of Life events coming up fix the bug by using named return values in the

function signature so the code will compile and run as intended Okay cool so this is the function we are interested