A gentle introduction to Google Go (Golang) for Beginners

In this lecture I'll:

• Summarize the tools we'll be installing and explaining GIT.

• Discuss Environment Variables and Paths (Critical thing to know!)

• Special things to know about Google Go (Golang) 1.8 and later

• Providing the installation roadmap for the lectures that follow.

In this lecture I'll:

• Provide step by step instructions on how to install Google Go (Golang) and GIT on a Windows 10 system. 

• Be sure to check out the included PDF manual on these steps as well!

In this lecture I'll:

• Provide step by step instructions on how to install Google Go (Golang) and GIT on a Ubuntu Linux system. 

• Be sure to check out the included PDF manual on these steps as well!

In this lecture I'll:

• Provide step by step instructions on how to install Google Go (Golang) and GIT on a Macintosh - OS X system. 

• Be sure to check out the included PDF manual on these steps as well!

In this lecture I'll:

• Provide step by step instructions on how to install Visual Studio Code a Windows 10 system.

• Install the Google Go (Golang) plugin.

• Run our very first (Hello World) program.

• Be sure to check out the included PDF manual on these steps as well!

In this lecture I'll:

• Provide step by step instructions on how to install Visual Studio Code on a Ubuntu Linux system.

• Install the Google Go (Golang) plugin.

• Run our very first (Hello World) program.

• Be sure to check out the included PDF manual on these steps as well!

In this lecture I'll:

• Provide step by step instructions on how to install Visual Studio Code on a Macintosh - OS X system.

• Install the Google Go (Golang) plugin.

• Run our very first (Hello World) program.

• Be sure to check out the included PDF manual on these steps as well!

In this lecture and it's downloadable PDF resource file - we'll explore:

• Must have resources to aid you on your journey in mastering Google Go (Golang).  

• Explore "cheat sheets" , free books and manuals, as well as guide for Golang syntax and keywords later on.  

In this first lecture of a four part series, we'll:

• Define the three fundamental parts of any computer system.

• Explore how binary works.

• End the lecture with a joke you can stump all your non-technical friends with! 

In this second lecture of a four part series, we'll:

• Dive into Hexadecimal numbers.  Hexawhat?  Exactly.  

• Make sense of Hexadecimal number systems that will be a foundation for understanding memory addresses and "passing by reference" vs. "Passing by Value" later on.  

In this third lecture of a four part series, we'll:

• Discuss the three essential parts to a computer.

• Define what processing actually is.

In our fourth and final part of the lecture series on what is programming - we'll:

• Tie everything together.  This is the best lecture in this entire course!

• Learn how high level computer languages give us an easier way to access the CPU and Memory - and what that really means.  

In this lecture, we'll:

• Dive into all the aspects of the Hello World program.  

• Avoid the "chicken and the egg problem" that often plagues other introductory courses on Golang.  How do you make something make sense, when.... ideas and concepts depend on each other?

• Explore a high level view of the program, and how all the ideas work together - to be prepared to understand all the pieces later on.

In this first of a three part lecture series on Variables and Constants, we'll:

• Define how variables are defined.  

• Explore precision and the types of datatypes Google Go (Golang) supports.  

• Explain how variables actually work under the covers - and use memory.

In this second part of the three part lecture series on Variables and Constants we'll:

• Declare and explore Boolean date types

• Declare and explore Float data types

• Declare and explore Integer data types

• Declare and explore String data types

• Declare and explore Complex data types  (yes, not kidding!) 

• Explore three things you must know about Google Go (Golang) about using variables!

  
  

In this third and final part of the lecture series on Variables and Constants we'll:

• Explore the three different ways variables can be created in Google Go (Golang).  

• We highlight which ways are better than others; and the difference between Declaration, Initialization, and Assignments.

• Finish off by exploring how constants are declared and used. 

  
  

In this lecture we explain expressions, which is often over looked from experienced programmers.  This lecture is super important and key to really understanding Google Go and Golang.  In it we'll discuss:

• The Built-in Golang General Arithmetic Operators 

• Basic Type Conversion (Important for like, everywhere!)

• Boolean Expressions (Important for use in Conditionals) 

• General Boolean Operators 

In this hands on lecture for visual studio code we'll:

• Explore the role of breakpoints and how to pause execution throughout a program

• Examining variable changing values from the execution of a program.

In this lecture we'll:

• Explore a common problem people can experience when developing programs in Google Go (golang)

• Look at how to develop and create each example going forward in Visual Studio Code.

In this first lecture in a two part lecture series on loops - we'll:

• We'll see what it takes to make a New Years Eve Countdown... the hard way.  

• This hands on lecture will set us up for successfully implementing real loops - where we can count down from any number we want...  

In this final lecture in the two part series on loops, we'll:

• Revise our New Years Eve countdown timer, to use a loop.  

• We'll explore the power of Golang loops and know - we can start our countdown from number that we want!  

In this first of a three part lecture series on Conditional Statements we'll:

• Introduce the basic If statement.

• Do a hands on example that separates the "young-ins" from those with more grey hair... and experience.  

In this second of a three part lecture series on Conditional Statements we'll:

• Simplifying our code with the else if statement.  

In this third and final lecture of a three part lecture series on Conditional Statements we'll:

• Conclude our discussion on IF, by introducing the else statement.

• Recap with fundamental points, so you don't get stuck by Google Go (Golang) later on.  

In this first lecture of a three part lecture series on switch, we'll:

• Create our hands on example, which includes even a partridge in a pear tree! 

• This hands on example... will grow to illustrate the power of switch to simplify things - but also later on, set us up to really introduce how Golang is different than most other languages and it's most advanced switching features.

• This lecture establishes that example.

In this second lecture of a three part series on switch, we'll:

• Get hands on with switch and use it to simplify our code substantially from the previous lecture.

• Create and use basic switch.

In this final and third lecture of a three part series on switch, we'll:

• Introduce the fallthrough statement.

• Use the fallthrough statement to generate the entire classic song, in a blink of an eye.

• Really explain how breaking works in switch and how it's different than other languages in Google Go (golang)

  
  

In this first lecture of a four part lecture series on Functions , we'll:

• Explore the theory of functions.  

• Introduce the concept "of the stack", and blast through it's trickiness of "by value" and "reference" by tapping into our "super brain".  

• See a cool "playback" animation of a program running.  It really shows how this all works - under the covers.  

• This is a must see lecture, that covers off some really key stuff in Google Go (Golang). This is a longer than average lecture - but entirely worth while!

In this second lecture of a four part lecture series on Functions, we'll:

• Create "the simplest function" that ever was.

• Use the simple function to extend and develop more complicated functions in future lectures.

In this third lecture of a four part lecture series on Functions, we'll:

• Extend "the simplest function" that ever was, to get data back to the function caller.

• Make use of expressions.  If expressions are confusing be sure to review that lecture before coming back here.

In this fourth and final lecture of a four part lecture series on Functions, we'll:

• Use by value and by reference!  

• All the work - it's *ALL* come down to this!

This is the must see lecture that has built up to this amazing moment.  Don't be an average programmer, that's actually boggled by these concepts.  You can actually understand this!  

We've talked about scope earlier a fair bit.  But it's always been one of those "chicken and an egg problems".  How do you talk about scope before you talk about ... well nearly everything else?  With so much under your belts in mastering beginning go - it finally makes sense to go back and really define what scope is, how it works, and what it does.  And no... sorry - this isn't about the mouthwash.  

In this lecture about scope we'll explore:

• Package level scope

• Global scope

• Function level scope

• And general rules about scope and what scope actually is.

In this advanced debugging lecture we'll:

• Explore the functions of step over, step into, and step out

• Explore the stack and debugging where functions are involved.

In this first lecture of a four part lecture series about arrays and slices, we'll:

• Introduce the theory of arrays.  

While Arrays are barely used on their own with Google Go, they are essential to understanding slices... which will be up - just around the corner.  

In this second lecture of a four part lecture series about arrays and slices, we'll:

• We move beyond the theory of arrays and actually create a program that uses them.

• Explore fundamental limitations of arrays so we can see why slices are really important.

In this third lecture of a four part lecture series about arrays and slices, we'll:

• Highlight the theory of slices, and why they are an amazing feature of Google Go (golang).

With this information we'll be ready to implement slices... in the very next lecture. 

In this fourth and final lecture of arrays and slices, we'll:

• Modify our array example to use slices.

• Illustrate how slices work to overcome limitations of arrays.

In this advanced topic of simple statements, we'll:

• Discuss simple statements and how they work with If and Switch statements.  

• Discuss the use case of simple statements, for error handling. 

In this advanced topic of for range loops, we'll:

• Take our previous example of a for loop - and super charge it.

• Illustrate all the important pieces of syntax associated with a for range loop.

In this advanced topic of Variadic Functions we'll:

• Extend our example to include Variadic functions.

• See how variadic functions are simple and help write really clean, modular go code. 

And you'll get a vocabulary word which will show your Ninja credibility, in Google Go / Golang circles everywhere.  Just name drop "Variadic"... and they'll know that you have graduated to someone whom actually knows how to write - Go Code!

Sadly.. the time has come where this course is done.  Your journey doesn't have to end here however, and this lecture (and it's accompanying downloadable resource) show exactly - how to continue your journey in Google Go.... 

Golang my friend... Golang....