Job Ready Go : Land your first role with one of the leading modern programming languages

Cover
Title Page
Copyright Page
About the Authors
About the Technical Writer
About the Technical Editor
Acknowledgments
Contents at a Glance
Contents
Introduction
	What Does This Book Cover?
	Reader Support for This Book
		Companion Download Files
		How to Contact the Publisher
Part I The Basics of the Go Programming Language
	Lesson 1 Getting Started with Go
		Installing Go
			Downloading the Installation Files
			Starting the Installation of Go
		Testing the Installation
		Creating a Hello, World! Program
			Compiling and Running the Program
			Alternate Run Option
			Troubleshooting Hello, World!
			Formatting Your Go Code
		Multiple Versions of Go
		Online Editor for Go: The Go Playground
		Summary
		Exercises
			Exercise 1.1: Counting Fun
			Exercise 1.2: Counting More Fun
	Lesson 2 Understanding Go Basics
		Understanding Statements and Tokens
		Statements
		Comments
			Single-line Comments
			Block or Multi-line Comments
		Identifiers
			Case
			Naming Conventions
		Keywords
		Summary
		Exercises
			Exercise 2.1: Fixing Problems
			Exercise 2.2: Making a Statement
			Exercise 2.3: Go Is Fun!
			Exercise 2.4: Printing Without Repeating
			Exercise 2.5: Tagging Your Code
			Solution: Listing 2.12
	Lesson 3 Storing with Variables
		Variables
			Naming Variables
			Declaring and Initializing Variables
				Declaring and Initializing One Variable
				Declaring Multiple Variables
				Declaring and Initializing Multiple Variables
		Static vs. Dynamic Type Declaration
			Mixing Types of Declarations
			Mixing Type Declarations in a Single Statement
		Variable Scope
		Obtaining User Input
			Memory Address
			Scanning for Values
		Converting a String to a Number
		Numeric Data Types
			Architecture-Independent Integer Types
			Out-of-Range Values
			Implementation-Specific Integer Types
			Float Types
		Summary
		Exercises
			Exercise 3.1: Fixing Problems
			Exercise 3.2: Creating Variables
			Exercise 3.3: Fewer Lines
			Exercise 3.4: How It Is Assigned
			Exercise 3.5: Conversions
			Exercise 3.6: State Your State
			Exercise 3.7: Where You Live
			Exercise 3.8: Boxy Logic
			Exercise 3.9: Assigning Types
	Lesson 4 Performing Operations
		Arithmetic Operations
			Listing 4.1Using the arithmetic operators
			Mixing Number Types
			Type Casting Numbers
			PEMDAS
		Assignment Operations
			Addition and Subtraction Assignment Operations
			Multiplication, Division, and Modulus Assignment Operations
		Working with Booleans
		Relational Operations
			Assigning Values to Boolean Variables
			Using Mismatched Types in Relational Operations
		Boolean Operations
		Math Functions
		Bitwise Operations
		Random Numbers
			Limiting the Possible Value
			Seeding the Random Number Generator
		Summary
		Exercises
			Exercise 4.1: Resulting in 0
			Exercise 4.2: Truncating
			Exercise 4.3: Current Value of Deposit
			Exercise 4.4: Simple Interest
			Exercise 4.5: True and False
			Exercise 4.6: Functioning Math
			Exercise 4.7: Five Times the Basic Math
			Exercise 4.8: Using Relational Operators
			Exercise 4.9: Random Limits
	Lesson 5 Controlling Program Flow with Conditional Statements
		Conditional Statements
		Using an if Statement
		Working with Multiple Conditions
		Using an if-else Statement
		Creating Nested if Statements
		Using a switch Statement
			Executing More than One Case with fallthrough
			Using Multiple Expressions in One Case
			Using Conditions in Switch Cases
		Summary
		Exercises
			Exercise 5.1: Are You Rich?
			Exercise 5.2: Cat vs. Dog
			Exercise 5.3: Quiz
			Exercise 5.4: Seasons
			Exercise 5.5: Switching the Seasons
			Exercise 5.6: Quiz Generator
			Exercise 5.7: Coffee Shop
	Lesson 6 Controlling Program Flow with Loops
		Looping Statements
		for Loops
			Optional Items in a for Loop
			Go’s while Is for
			Infinite Loops
		Looping through a String
		The range Function
		Loop Control Statements
			The break Statement
			The continue Statement
			The goto Statement
		Summary
		Exercises
			Exercise 6.1: The Alphabet
			Exercise 6.2: Sum It Up
			Exercise 6.3: Fifty
			Exercise 6.4: Numeric Breakout
			Exercise 6.5: Reverse It
			Exercise 6.6: Length Without len
			Exercise 6.7: Guessing Game
			Exercise 6.8: URL Shortener
			Exercise 6.9: Validating Phone Numbers
			Exercise 6.10: Validating Email Addresses
			Exercise 6.11: Fizz Buzz
	Lesson 7 Pulling It All Together: Income Tax Calculator
		Getting Started
		Step 1: Gather Requirements
			Values in Use
			User Interface
			Other Standards
		Step 2: Design the Program
		Step 3: Create the Inputs
		Step 4: Calculate the Taxable Income
		Step 5: Calculate the Tax Rate
			Add a Conditional Statement
			Create Nested Conditionals
		Step 6: Update the Application
			What About Negative Taxable Incomes?
			Does Code Compare to Standards?
		Step 7: Address the UI
		On Your Own
		Summary
Part II Organizing Code and Data in Go
	Lesson 8 Using Functions
		Defining a Function
			Listing 8.1A simple add function
			Using Multiple Functions
			Functions with No Return Values
			Functions with Multiple Return Values
				Returning Different Types
				Returning Named Types
				Skipping a return value
		Variadic Functions
		Recursion
		Function as a Value
		Closures
		Summary
		Exercises
			Exercise 8.1: Creating Your Own Functions
			Exercise 8.2: Spheres
			Exercise 8.3: What Does the Fox Say?
			Exercise 8.4: Using Recursion
			Exercise 8.5: Fibonacci Function
			Exercise 8.6: A Calculator
	Lesson 9 Accessing Arrays
		Declaring an Array
			Assigning a Value to an Array Element
			Basic Rules of Arrays
			Similarity of an Array Element and Variable
		Declaring and Initializing an Array
		Inferring Array Size
		Using a for Loop to Define an Array
		Using Range with an Array
		Creating Multidimensional Arrays
		Duplicating an Array
		Comparing Arrays
		Summary
		Exercises
			Exercise 9.1: Two Arrays
			Exercise 9.2: Three Arrays
			Exercise 9.3: For Evens
			Exercise 9.4: Moving from One to Another
			Exercise 9.5: Forward and Backward
			Exercise 9.6: Two Dimensions of Four
			Exercise 9.7: Duplicating
			Exercise 9.8: Personal Data
	Lesson 10 Working with Pointers
		Creating a Pointer
			Initializing a Pointer
			Declaring and Initializing a Pointer
			Using Dynamic Typing
			Pointers of Different Types
		Accessing the Stored Value of a Pointer
		Understanding nil Pointers
		Using Pointers to Change Variables
		Comparing Pointers
		Working with an Array of Pointers
			Changing Values in an Array
		Using Pointers with Functions
			Changing Values from a Function
		Summary
		Exercises
			Exercise 10.1: Name, Age, and Gender
			Exercise 10.2: User Input
			Exercise 10.3: Playing with Pointers
			Exercise 10.4: Full Name
			Exercise 10.5: What’s It Doing?
			Exercise 10.6: Reverse
			Exercise 10.7: Sort
	Lesson 11 Organizing with Structs
		Declaring and Initializing a Struct
			Retrieving Values from a Struct
			Initializing a Struct When Declaring
			Using the Short Assignment Operator
		Using Key-Value Pairs with Structs
		Using the new Keyword
		Pointers and Structs
		Nested Structs
		Adding Methods to a Struct
		Type and Value
		Comparing Structs
		Summary
		Exercises
			Exercise 11.1: Addressing an Envelope
			Exercise 11.2: Name
			Exercise 11.3: Full Name
			Exercise 11.4: Address Book
			Exercise 11.5: Passing a Struct
			Exercise 11.6: Nesting Practice
			Exercise 11.7: Burger Shop
			Challenges
	Lesson 12 Accessing Slices
		How Slices Work
		Slice an Array
			Using len and cap
			Using Shortcuts
		Changing the Size of a Slice
		Iterating Through a Slice
		The make Function
		Creating a Slice Variable with var
		Working with Slice Elements
			Replacing an Element in a Slice
			Working with Empty Slices
			Working with a Section of a Slice
			Using range with Slices
		Appending to a Slice Using the append Function
		Copying a Slice
		Creating a Slice Using the new Keyword
		Removing an Item from a Slice
		Summary
		Exercises
			Exercise 12.1: Alphabet
			Exercise 12.2: Count the Letters
			Exercise 12.3: An Average Word
			Exercise 12.4: Student Names
			Exercise 12.5: No Blanks
			Exercise 12.6: Slicing Numbers Together
	Lesson 13 Manipulating Maps
		Defining a Map
			Maintaining Type
			Duplicating Keys
		Empty Maps
		Creating a Map Using make
		Map Length
		Retrieving Map Elements
		Checking for a Key
		Iterating Through a Map
		Deleting Map Elements
		Literal Declarations in Maps
		Summary
		Exercises
			Exercise 13.1: Creating Your Own Map
			Exercise 13.2: User Input
			Exercise 13.3: Looping
			Exercise 13.4: Does It Exist?
			Exercise 13.5: State Populations
			Exercise 13.6: Keyword Search
	Lesson 14 Creating Methods
		Working with Methods
		Defining a Method
		Using Pointers with Methods
		Naming Methods
		Working with Value Receivers and Arguments
		Working with Pointer Receivers and Arguments
		Summary
		Exercises
			Exercise 14.1: Functioning with Integers
			Exercise 14.2: Methods with Integers
			Exercise 14.3: Volume of a Solid
			Exercise 14.4: Banking Terminal
				Bank Account
				Wallet
				Define the Methods
				main Function
				Challenge
	Lesson 15 Adding Interfaces
		Creating an Interface
		Interfaces and Code Reusability
		Static vs. Dynamic Interface Types
		Empty Interfaces
		Checking an Interface Type
		Multiple Interfaces
		Embedded Interfaces
		Summary
		Exercises
			Exercise 15.1: Rectangle Sides
			Exercise 15.2: Rectangle Space
			Exercise 15.3: Rectangle Borders
			Exercise 15.4: Triangles and Rectangles
			Exercise 15.5: Circles and Other Shapes
	Lesson 16 Pulling It All Together: Building a Burger Shop
		Requirements for Our Application
		Planing the Code
		Creating the Structs
			Creating a burger Struct
			Creating a drink Struct
			Creating a side Struct
			Creating a combo Struct
			Creating the order Struct
		Creating the Helper Functions
			Ordering a Burger
			Ordering a Side
			Ordering a Drink
			Ordering a Combo
		Tying the Code Together
		Summary
		The Full Burger Shop Listing
Part III Creating Job Ready Solutions in Go
	Lesson 17 Handling Errors
		Errors in Go Programs
		The Go Error Type
		Custom Error Handling
		Error Methods
		Errorf
		Blank Identifiers
		Error Messages with Structs
		Multiple Custom Error Messages
		Summary
		Exercises
			Exercise 17.1: Not an Error
			Exercise 17.2: Greedy Withdrawal
			Exercise 17.3: Extending the Banking Application
			Exercise 17.4: On Your Own
	Lesson 18 Concurrency
		Using Concurrency
			The Role of the Operating System
			Problems with Concurrency
			Mutual Exclusion
		Parallelism
			Implementing Parallelism
			Preventing Problems with Parallelism
		Using Goroutines
		Multiple Goroutines
		Working with Channels
			Creating a Channel Using make
			Channels and Concurrency
			Adding a Delay
		Channels with Multiple Goroutines
		Closing Channels
		Iterating Through a Channel
		Summary
		Exercises
			Exercise 18.1: Counting Up and Down
			Exercise 18.2: Passing to a Goroutine
			Exercise 18.3: Rolling the Die
			Exercise 18.4: Rolling the Dice
	Lesson 19 Sorting and Data Processing
		Sorting
			Checking Sorted Values
			Custom Sort Functions
			Reversing the Sort Order
		Time and Date Operations
			Defining a Time
			Comparing Times
			Time Math
				Determining Date Differences
				Adding a Duration to a Date/Time
				Adding Hours, Minutes, and Seconds
				Adding Years, Months, and Days
			Parsing Time
			Working with Unix Time
			Formatting Standard Times
		Regular Expressions
		Summary
		Exercises
			Exercise 19.1: Sorting Floats
			Exercise 19.2: Sorting Student Grades
			Exercise 19.3: Knowing What Time It Is
			Exercise 19.4: Working with Dates
			Exercise 19.5: String Searching
			Exercise 19.6: More String Searching
			Exercise 19.7: Date-Time Calculator
				Calculator 1: Time Duration
				Calculator 2: Add Time to or Subtract Time from a Date
				Calculator 3: Age Calculator
	Lesson 20 File I/O and OS Operations
		Reading a File
			The panic Function
			Reading a Subset of a File
			The defer Statement
			Reading a File from a Specific Starting Point
			Buffered Reader
			Reading a File Line by Line
		Writing to a File
			Creating a New File
			Buffered Writer
		Working with Directories
			Creating a Directory
			Deleting a Directory
			Creating a Directory Tree
			Listing Directory Contents
			Changing a Directory
			Temporary Files and Directories
		Command-Line Arguments
		Summary
		Exercises
			Exercise 20.1: Text Filing
			Exercise 20.2: Jumping Around
			Exercise 20.3: Counting Letters
			Exercise 20.4: Copying a File
			Exercise 20.5: Copying a File, Take 2
			Exercise 20.6: Burger Shop
	Lesson 21 Pulling It All Together: Word Analysis in Go
		Examining the Data
		Reading the Review Data
			Returning the Reviews
		Tokenizing an Input String
			Identifying and Replacing Punctuation with a Space
			Converting Input Text to Lowercase
			Splitting the String into Words
		Creating a Tokenize Function
			Tokenizing an Input Review
			Tokenizing the Entire Dataset
		Counting the Words in Each Review
		Tokenizing and Counting the Reviews
		Designing Improvements
			Improvement 1: Improving the Structs
				Update read_json_file
				Update to Tokenize
				main Function Update
				Word Count Update
			Improvement 2: Adding Custom Error and Exception Handling
			Improvement 3: Improving Tokenizing
			Improvement 4: Improving Word Counting
		Possible Further Improvements
		Final Code Listing
		Summary
Part IV Advanced Topics for Go Development
	Lesson 22 Testing
		Test-Driven Development
		Testing Levels
		The TDD Workflow
			The TDD Process
			Advantages of TDD
		The Testing Package
			Creating the Program
			Writing the Test
			Running the Test
		Tutorial: Test-Driven Development
			First Test: String Representation of Dollar Amount
				Add a Test
				Write the Program
				Run the Test
			Second Test: Test with Other Values
				Add a Test
				Reconfigure the Test
				Reconfigure the Program
			Third Test: Operation Output
				Add a Test
				Reconfigure the Program
				Run the Test
				Test the Test
				Refactor SubtractFormatAmount
				Run the Test
			Examining the Tests
				Test Coverage
				Coverage Reports
			Fourth Test: Include Subtraction
				Add a Test
				Refactor the Program
				Run the Test
			Final Tests: Look at Input Values
				Add a Test
				Update the Tests
				Refactor the Program
				Run the Test
		Behavior-Driven Development
			Goals of Behavior-Driven Development
			Avoiding Failure
			Behavior Specifications
			Defining User Stories
				Specification Workshops
				Executable Specifications
		Summary
		Exercises
			Exercise 22.1: Breaking the Square
			Exercise 22.2: Adding More to Dollar
	Lesson 23 API Development Tutorial
		Overview and Requirements
		Step 1: Create the Dataset and a Simple API
			Defining the Dataset
			The homePage Function
			Return Handler
			Handling and Routing Incoming Requests
			Adding Data
			Executing the Request Handler
			Running the Program
		Step 2: Add a Router: Gorilla Mux
		Step 3: Retrieve a Record
			Retrieving a Specific Record
			Testing the Updates
		Step 4: Add a New Record
		Step 5: Delete a Record
		Summary
		Exercises
			Exercise 23.1: Students
			Exercise 23.2: Student Name
			Exercise 23.3: Going Local
	Lesson 24 Working with gRPC
		Working with gRPC
		Setting Up the Services
			Git
			gRPC
			Protobuf
			Protoc
			User Directory
		Creating a Server
		Creating a gRPC Server
		Creating the Chat Service
		Updating the Server Code to Include the Chat Service
		Creating the chat Package
		Creating a Client
		Running the Server and the Client
		Summary
		Exercises
			Exercise 24.1: Chat Assistant
			Exercise 24.2: The Real Weather
			Exercise 24.3: Adding Stock
	Lesson 25 Pulling It All Together: Using Smart Data
		Project Overview
		Designing Our API
		Implementing the gRPC Server
			The Geolocation Server Shell
				Accessing Google Location Data
				Updating geolocation.go
				Updating client_geolocation.go
			The Finance Server Shell
				Accessing Yahoo Finance Quotes
				Signing Up for a Yahoo Finance API Key
				Querying the Yahoo Finance API Programmatically
				Updating GetQuoteData
				Testing Our Quote RPC
		Creating the API
			Implementing the getGeoLocationData Endpoints
			Implementing the getQuote Endpoint
			Updating the api.go File
		Summary
	Lesson 26 Using Modules
		Getting Started with Modules
		Step 1: Create the Project Directory
		Step 2: Create Your Program(s)
		Step 3: Create a Test Program
		Step 4: Create the go.mod File
		Step 5: Test the Module
		Step 6: Using the Module
		Naming Module Functions
		Summary
		Exercises
			Exercise 26.1: Shouting Text
			Exercise 26.2: Shouting Correctly
			Exercise 26.3: Shout It!
			Exercise 26.4: On Your Own
Appendix File Permissions and Access Rights
Index
EULA