O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Beginner Solutions in Go – The Basics, Clients, and Servers

Video Description

Build foundation for your applications with the basic understanding of Go

About This Video

  • Discover a number of solutions and approaches to develop modern back-end applications

  • Put to use the best practices to combine the solutions for sophisticated parallel tools

  • This video is based on Go version 1.6 and above

  • In Detail

    Go (a.k.a. Golang) is a statically-typed programming language first developed at Google. It is derived from C with additional features such as garbage collection, type safety, dynamic-typing capabilities, additional built-in types, and a large standard library.

    This course takes off where basic tutorials on the language leave off. You can immediately put into practice some of the more advanced concepts and libraries offered by the language while avoiding some of the common mistakes for new Go developers.

    The course covers basic type and error handling. It explores applications that interact with users, such as command-line tools or via the file system.

    Table of Contents

    1. Chapter 1 : I/O and File Systems
      1. The Course Overview 00:02:37
      2. Using the Common I/O Interfaces 00:04:42
      3. Using the Bytes and Strings Packages 00:04:11
      4. Working with Directories and Files 00:02:17
      5. Working with the CSV format 00:03:11
      6. Working with Temporary Files 00:02:09
      7. Working with Text/Template and HTML/Templates 00:02:58
    2. Chapter 2 : Command-Line Tools
      1. Using Command-Line Flags 00:03:08
      2. Using Command-Line Arguments 00:02:05
      3. Reading and Setting Environment Variables 00:03:37
      4. Configuration Using TOML, YAML, and JSON 00:03:22
      5. Working with Unix Pipes 00:02:16
      6. Catching and Handling Signals 00:02:12
      7. An ANSI Coloring Application 00:02:34
    3. Chapter 3 : Data Conversion and Composition
      1. Converting Data Types and Interface Casting 00:03:21
      2. Working with Numeric Data Types using math and math/big 00:03:08
      3. Currency Conversions and float64 considerations 00:03:26
      4. Using Pointers and SQL NullTypes for Encoding and Decoding 00:02:43
      5. Encoding and Decoding Go Data 00:02:23
      6. Struct Tags and Basic Reflection in Go 00:03:02
      7. Implementing Collections Via Closures 00:02:47
    4. Chapter 4 : Error Handling in Go
      1. Handling Errors and the Error Interface 00:02:28
      2. Using the pkg/errors Package and Wrapping Errors 00:02:45
      3. Using the log Package and Understanding When to Log Errors 00:02:43
      4. Structured Logging with the apex and logrus Packages 00:02:53
      5. Logging with the context Package 00:02:32
      6. Using Package-Level Global Variables 00:02:15
      7. Catching Panics for Long Running Processes 00:01:44
    5. Chapter 5 : All about Databases and Storage
      1. The database/sql Package with MySQL 00:04:34
      2. Executing a Database Transaction Interface 00:02:30
      3. Connection Pooling, Rate Limiting, and Timeouts for SQL 00:02:17
      4. 5_4_T 00:02:29
      5. Using NoSQL with MongoDB and mgo 00:01:55
      6. Creating Storage Interfaces for Data Portability 00:03:36
    6. Chapter 6 : Web Clients and APIs
      1. Initializing, Storing, and Passing http.Client structs 00:03:40
      2. Writing a Client for a REST API 00:02:46
      3. Executing Parallel and Async Client Requests 00:01:59
      4. Making Use of OAuth2 Clients 00:04:08
      5. Implementing an OAuth2 Token Storage Interface 00:04:09
      6. Wrapping a Client in Added Functionality and Function Composition 00:02:38
      7. Understanding GRPC Clients 00:04:38
    7. Chapter 7 : Microservices for Applications in Go
      1. Working with Web Handlers, Requests, and ResponseWriters 00:03:40
      2. Using Structs and Closures for Stateful Handlers 00:03:15
      3. Validating Input for Go structs and User Inputs 00:03:11
      4. Rendering and Content Negotiation 00:02:09
      5. Implementing and Using Middleware 00:02:30
      6. Building a Reverse Proxy Application 00:02:28
      7. Exporting GRPC as a JSON API 00:04:36