Mini Map
Search
⌘ K
Log In
The Way to Go
0%
1.
Origin, Context and Popularity of GO
Origin and Evolution of Go
Reasons for Developing Go
Characteristics of Go
Test Yourself
2.
Basic Constructs and Elementary Data Types
Filenames, Keywords and Identifiers
Import Functionality
Overview of Functions
Overview of Data Types
Constants
Variables
Scope of Variables
Elementary Types
Operators
Challenge: Temperature Conversion
Solution Review: Temperature Conversion
Strings
Strings and strconv Package
Times and Dates
Pointers
Quiz: Deduce the Outputs
3.
Control Structures
The if-else Construct
Testing for Errors on Functions
The switch-case Construct
Challenge: Season of a Month
Solution Review: Season of a Month
The for Construct
The for range Construct
Break and Continue
Use of Labels - goto
Exercise: Deduce the Outputs
4.
Functions
Introduction to Functions
Parameters and Return Values
Challenge: Multiple Return Values
Solution Review: Multiple Return Values
Challenge: Variable Number of Arguments
Solution Review: Variable Number of Arguments
Defer and Tracing
Built-in Functions
Recursive Functions
Challenge: Compute Factorial of a Number
Solution Review: Compute Factorial of a Number
Higher-Order Functions
Challenge: Filter Even and Odd Numbers
Solution Review: Filter Even and Odd Numbers
Closures
Functions as Return Variables
Debugging with Closures
Optimizing Programs
Quiz: Deduce the Outputs
5.
Arrays and Slices
Declaration and Initialization
Array Literals and Parameters
Challenge: Filling Array with Loop Counter
Solution Review: Filling Array with Loop Counter
Challenge: Finding Fibonacci Numbers with Array
Solution Review: Finding Fibonacci Numbers with Array
Slices
Slices with Functions
Challenge: Finding Fibonacci Numbers with Slices
Solution Review: Finding Fibonacci Numbers with Slices
Multidimensionality
Bytes and Slices
The for-range Construct
Reslicing
Copying and Appending Slices
Challenge: Magnify a Slice
Solution Review: Magnify a Slice
Challenge: Inserting Slice in a Slice
Solution Review: Inserting Slice in a Slice
Challenge: Filtering with Higher-Order Functions
Solution Review: Filtering with Higher-Order Functions
Applying Strings, Arrays and Slices
Challenge: Bubble Sort the Slice
Solution Review: Bubble Sort the Slice
Challenge: Reverse a String
Solution Review: Reverse a String
Quiz: Deduce the Outputs
6.
Maps
Declaration and Initialization
Existence of Key-Value Item
The for range Construct
Challenge: Map the Days
Solution Review: Map the Days
A Slice of Maps
Sorting and Inverting a Map
Quiz: Deduce the Outputs
7.
Packages
Overview of the Standard Library
Challenge: Construct a Double-Linked List
Solution Review: Construct a Double-Linked List
The regexp Package
Locking and the sync Package
Accurate Computations and the big Package
Custom Packages and Visibility
Documenting Your Packages
Custom Packages: Folder Structure, go install and go test
Using git for Distribution
External Packages, Projects and Libraries
Installing External Packages
8.
Structs and Methods
Introduction to Struct
Advanced Structs Concepts
Factory Method
Structs with Tags
Anonymous Fields and Embedded Structs
Challenge: Anonymous Struct
Solution Review: Anonymous Struct
Introduction to Methods
Methods Versus Functions
Challenge: Coordinates of a Point
Solution Review: Coordinates of a Point
Challenge: Make a Rectangle
Solution Review: Make a Rectangle
Challenge: Decide Employee Salary
Solution Review: Decide Employee Salary
Receivers and Methods as Pointers and Values
Non-Exported Fields
String() Method and Format Specifiers
Methods on Embedded Types
Multiple Inheritance
Challenge: Implement Stack Data Structure
Solution Review: Implement Stack Data Structure
Garbage Collection and SetFinalizer
Quiz: Deduce the Outputs
9.
Interfaces and Reflection
What is an Interface?
Challenge: Make a Simple Interface
Solution Review: Make a Simple Interface
Embedded Interface and Type Assertions
The Type Switch
Challenge: Advancing the Simple Interface
Solution Review: Advancing the Simple Interface
Implementation of Interfaces
Sorting with the Sorter Interface
Challenge: Advancing the Shapes Analysis
Solution Review: Advancing the Shapes Analysis
Challenge: Sort People with Sorter Interface
Solution Review: Sort People with Sorter Interface
Reading and Writing
Empty Interface
Challenge: Implement Miner Interface
Solution Review: Implement Miner Interface
The reflect Package
Printf and Reflection
Interfaces and Dynamic Typing
Structs, Collections and Higher-Order Functions
Challenge: Make a Stack with Variable Internal Types
Solution Review: Make a Stack with Variable Internal Types
The Object Orientation in Go
Quiz: Deduce the Outputs
10.
Reading and Writing
Reading Input from the User
Challenge: Analyzing Input from Keyboard
Solution Review: Analyzing Input from Keyboard
Reading from a File
Writing to a File
Challenge: Read CSV File
Solution Review: Read CSV File
Challenge: Writing to a WIKI Page
Solution Review: Writing to a WIKI Page
Copying Files
Reading Arguments from the Command-Line
Reading Files with a Buffer
Reading and Writing Files with Slices
Scanning Inputs
A Practical Example of Interfaces
The JSON Data Format
Decoding with JSON
The XML Data Format
Data Transport through gob
Challenge: Decode the Contents
Solution Review: Decode the Contents
Cryptography with Go
Exercise: Deduce the Outputs
11.
Error-Handling and Testing
Error-Handling
Run-time Exceptions and Panic
Recover
Error-Handling and Panicking in a User-Defined Package
Error-Handling Scheme with Closures
Challenge: Generate Panic from Division by 0
Solution Review: Generate Panic from Division by 0
Starting an External Command or Program
Testing and Benchmarking in Go
Testing: A Concrete Example
Using Table-Driven Tests
Investigating Performance
Exercise: Deduce the Outputs
12.
Goroutines and Channels
Handling Concurrency and Parallelism with Go
Implementing Goroutines
Introduction to Channels
Synchronous and Asynchronous Communication
Challenge: Demonstrate the Blocking Nature
Solution Review: Demonstrate the Blocking Nature
Semaphore Pattern
Channel Factory and Producer-Consumer Pattern
Challenge: Summing the Integers
Solution Review: Summing the Integers
Channel Directionality
Synchronization of goroutines
Switching between goroutines
Challenge: Devise Random Bit Generator
Solution Review: Devise Random Bit Generator
Challenge: Map Polar Points to Cartesian Points
Solution Review: Map Polar Points to Cartesian Points
Channels, Timeouts, and Tickers
Using recover with goroutines
Tasks and Worker Processes
Implementing a Lazy Generator
Anonymous Closure
Implementing Futures
Multiplexing
Limiting the Number of Requests
Chaining and Parallelizing Computation
The Leaky Bucket Algorithm
Benchmarking, Accessing and Listening
Exercise: Deduce the Outputs
13.
Networking, Templating and Web-Applications
A TCP Server
A Simple Web Server
Polling Websites and Reading Web Page
Writing a Simple Web Application
Challenge: Web Application for Statistics
Solution Review: Web Application for Statistics
Making a Web Application Robust
Writing Web Application with Templates
Exploring the template Package
Challenge: Web Application for Serving Guests
Solution Review: Web Application for Serving Guests
An Elaborate Web Server
Remote Procedure Calls with RPC
Sending Mails with SMTP
Go in the Cloud
14.
Common Go Pitfalls and Patterns
Regular Mistakes and Suggestions
Highlights from the Previous Chapters
The comma, ok Pattern
The defer Pattern
Visibility and Operator Patterns
15.
Performance Advices
Strings, Arrays and Slices
Structs, Interfaces and Maps
Functions and Files
Goroutines and Networking
Suggestions and Considerations
16.
Building a Complete Application
Introduction
Setting up the Structure of Application
Our User Interface
Persistent Storage with gob
Using goroutines for Performance
Persistent Storage with JSON
Enhancements
17.
Appendix
Platforms and Architectures
Installing Go and the Go Tools-Chain in Binary Format
Installing Go from Source
Go Work Environment
Basic Requirements for a Go Environment
Editors and Integrated Development Environments
Debugging
Formatting the Code
Building and Running Go-Programs
Searching for Help and Documenting the Code
Tools and Go's Performance
Interaction with C and C++
Helpful Resources
Home
/
Courses
/
The Way to Go
Challenge: Summing the Integers
This lesson brings you a challenge to solve.
We'll cover the following...
Problem statement
Problem statement
...