Tags
Language
Tags
June 2025
Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 1 2 3 4 5
    Attention❗ To save your time, in order to download anything on this site, you must be registered 👉 HERE. If you do not have a registration yet, it is better to do it right away. ✌

    ( • )( • ) ( ͡⚆ ͜ʖ ͡⚆ ) (‿ˠ‿)
    SpicyMags.xyz

    Learning Path: Go: Real-World Go Solutions For Gophers

    Posted By: ELK1nG
    Learning Path: Go: Real-World Go Solutions For Gophers

    Learning Path: Go: Real-World Go Solutions For Gophers
    Last updated 12/2017
    MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
    Language: English | Size: 483.34 MB | Duration: 4h 10m

    Develop modular and testable applications in Go!

    What you'll learn

    Explore working with filesystems

    Process common datatypes such as TOML, YAML, and JSON

    Explore strategies to handle errors in Go

    Implement Go HTTP client interfaces, REST clients, OAuth2 clients

    Explore web handlers, validation of user input, and middleware

    Handle errors and cleanly pass them along to calling functions Wrap dependencies in interfaces for ease of portability and testing

    Explore reactive programming design patterns in Go

    Requirements

    Prior Basic Knowledge of Go programming language is needed

    Basic understanding of JSON and MySQL is needed

    Description

    Go is one of the most powerful, efficient, and highly-performant programming languages. It has seen an increased rate of adoption mainly because it is lightweight, easy to use and displays great robustness when performing in a variety of domains. Go is an open source programming language that makes it easy to build simple, reliable, and efficient software. Go (often referred to as golang) is a programming language created at Google in 2009. 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. If you're interested to build a foundation for your applications so as to improve its performance, then go for this Learning Path.
    Packt’s Video Learning Paths are a series of individual video products put together in a logical and stepwise manner such that each video builds on the skills learned in the video before it.
    The highlights of this Learning Path are:
    Learn encoding strategies and some functional design patterns for GoDeal with various storage libraries for accessing data storage systems such as MySQLTest your application using advanced testing methodologies
    Let’s take a quick look at your learning journey. This Learning Path starts off with 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. Initially you will work upon I/O file systems and command line tools. Error handling feature of Go will help you with structured logging, logging with context package, etc. You will also learn about databases and storage using MySQL and NoSQL with MongoDB. You will also come across microservices that improves your Go applications.
    Further, this path explores applications that interact with users, such as websites, command-line tools, or via the file system. It demonstrates how to handle advanced topics such as parallelism, distributed systems, and performance tuning. Lastly, it finishes with reactive and serverless programming in Go. You will learn about serverless programming and also tips and tricks to improve performance of your application.
    By the end of this Learning Path, you will be able to bridge the gap between basic understanding of Go and use of its advanced features to build foundation for your applications.
    Meet Your Experts:
    We have combined the best works of the following esteemed authors to ensure that your learning journey is smooth:
    Aaron Torres received his master’s of science degree in computer science from New Mexico Institute of Mining and Technology. He has worked on distributed systems in high performance computing and in large-scale web and microservices applications. He currently leads a team of Go developers that refines and focuses on Go best practices with an emphasis on continuous delivery and automated testing. Aaron has published a number of papers and has several patents in the area of storage and I/O. He is passionate about sharing his knowledge and ideas with others. He is also a huge fan of the Go language and open source for backend systems and development.


    Overview

    Section 1: Beginner Solutions in Go - The Basics, Clients, and Servers

    Lecture 1 The Course Overview

    Lecture 2 Using the Common I/O Interfaces

    Lecture 3 Using the Bytes and Strings Packages

    Lecture 4 Working with Directories and Files

    Lecture 5 Working with the CSV format

    Lecture 6 Working with Temporary Files

    Lecture 7 Working with Text/Template and HTML/Templates

    Lecture 8 Using Command-Line Flags

    Lecture 9 Using Command-Line Arguments

    Lecture 10 Reading and Setting Environment Variables

    Lecture 11 Configuration Using TOML, YAML, and JSON

    Lecture 12 Working with Unix Pipes

    Lecture 13 Catching and Handling Signals

    Lecture 14 An ANSI Coloring Application

    Lecture 15 Converting Data Types and Interface Casting

    Lecture 16 Working with Numeric Data Types using math and math/big

    Lecture 17 Currency Conversions and float64 considerations

    Lecture 18 Using Pointers and SQL NullTypes for Encoding and Decoding

    Lecture 19 Encoding and Decoding Go Data

    Lecture 20 Struct Tags and Basic Reflection in Go

    Lecture 21 Implementing Collections Via Closures

    Lecture 22 Handling Errors and the Error Interface

    Lecture 23 Using the pkg/errors Package and Wrapping Errors

    Lecture 24 Using the log Package and Understanding When to Log Errors

    Lecture 25 Structured Logging with the apex and logrus Packages

    Lecture 26 Logging with the context Package

    Lecture 27 Using Package-Level Global Variables

    Lecture 28 Catching Panics for Long Running Processes

    Lecture 29 The database/sql Package with MySQL

    Lecture 30 Executing a Database Transaction Interface

    Lecture 31 Connection Pooling, Rate Limiting, and Timeouts for SQL

    Lecture 32 Working with Redis

    Lecture 33 Using NoSQL with MongoDB and mgo

    Lecture 34 Creating Storage Interfaces for Data Portability

    Lecture 35 Initializing, Storing, and Passing http.Client structs

    Lecture 36 Writing a Client for a REST API

    Lecture 37 Executing Parallel and Async Client Requests

    Lecture 38 Making Use of OAuth2 Clients

    Lecture 39 Implementing an OAuth2 Token Storage Interface

    Lecture 40 Wrapping a Client in Added Functionality and Function Composition

    Lecture 41 Understanding GRPC Clients

    Lecture 42 Working with Web Handlers, Requests, and ResponseWriters

    Lecture 43 Using Structs and Closures for Stateful Handlers

    Lecture 44 Validating Input for Go structs and User Inputs

    Lecture 45 Rendering and Content Negotiation

    Lecture 46 Implementing and Using Middleware

    Lecture 47 Building a Reverse Proxy Application

    Lecture 48 Exporting GRPC as a JSON API

    Section 2: Advanced Solutions in Go - Testing and Distributed Systems

    Lecture 49 The Course Overview

    Lecture 50 Mocking Using the Standard Library

    Lecture 51 Using the mockgen Package

    Lecture 52 Using Table-Driven Tests to Improve Coverage

    Lecture 53 Using Third-Party Testing Tools

    Lecture 54 Practical Fuzzing

    Lecture 55 Behavior Testing Using Go

    Lecture 56 Using channels and the select Statement

    Lecture 57 Performing async Operations withsync.WaitGroup

    Lecture 58 Using Atomic Operations and mutex

    Lecture 59 Using the context Package

    Lecture 60 Executing State Management for Channels

    Lecture 61 Using the Worker Pool Design Pattern

    Lecture 62 Using Workers to Create Pipelines

    Lecture 63 Using Service Discovery with Consul

    Lecture 64 Implementing Basic Consensus Using Raft

    Lecture 65 Using Containerization with Docker

    Lecture 66 Orchestration and Deployment Strategies

    Lecture 67 Monitoring Applications

    Lecture 68 Collecting Metrics

    Lecture 69 goflow for Dataflow Programming

    Lecture 70 Reactive Programming with RxGo

    Lecture 71 Using Kafka with Sarama

    Lecture 72 Using async Producers with Kafka

    Lecture 73 Connecting Kafka to goflow

    Lecture 74 Defining a GraphQL Server in Go

    Lecture 75 Go Programming on Lambda with Apex

    Lecture 76 Apex Serverless Logging and Metrics

    Lecture 77 Google App Engine with Go

    Lecture 78 Working with Firebase Using zabawaba99/firego

    Lecture 79 Using the pprof Tool

    Lecture 80 Benchmarking and Finding Bottlenecks

    Lecture 81 Memory Allocation and Heap Management

    Lecture 82 Vendoring and Project Layout

    Lecture 83 Using fasthttprouter and fasthttp

    This Learning Path is for web developers, programmers, and enterprise developers, who want to build a foundation for their applications with the advanced features of Go.