Hands-On System Programming with Go电子书

Dedication

About Packt

Why subscribe?

Contributors

About the author

About the reviewers

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Download the color images

Code in Action

Playground examples

Conventions used

Get in touch

Reviews

Section 1: An Introduction to System Programming and Go

An Introduction to System Programming

Technical requirements

Beginning with system programming

Software for software

Languages and system evolution

System programming and software engineering

Application programming interfaces

Types of APIs

Operating systems

Libraries and frameworks

Remote APIs

Web APIs

Understanding the protection ring

Architectural differences

Kernel space and user space

Diving into system calls

Services provided

Process control

File management

Device management

Information maintenance

Communication

The difference between operating systems

Understanding the POSIX standard

POSIX standards and features

POSIX.1 – core services

POSIX.1b and POSIX.1c – real-time and thread extensions

POSIX.2 – shell and utilities

OS adherence

Linux and macOS

Windows

Summary

Questions

Unix OS Components

Technical requirements

Memory management

Techniques of management

Virtual memory

Understanding files and filesystems

Operating systems and filesystems

Linux

macOS

Windows

Files and hard and soft links

Unix filesystem

Root and inodes

Directory structure

Navigation and interaction

Mounting and unmounting

Processes

Process properties

Process life cycle

Foreground and background

Killing a job

Users, groups, and permissions

Users and groups

Owner, group, and others

Read, write, and execute

Changing permission

Process communications

Exit codes

Signals

Pipes

Sockets

Summary

Questions

An Overview of Go

Technical requirements

Language features

History of Go

Strengths and weaknesses

Namespace

Imports and exporting symbols

Type system

Basic types

Composite types

Custom-defined types

Variables and functions

Handling variables

Declaration

Operations

Casting

Scope

Constants

Functions and methods

Values and pointers

Understanding flow control

Condition

Looping

Exploring built-in functions

Defer, panic, and recover

Concurrency model

Understanding channels and goroutines

Understanding memory management

Stack and heap

The history of GC in Go

Building and compiling programs

Install

Build

Run

Summary

Questions

Section 2: Advanced File I/O Operations

Working with the Filesystem

Technical requirements

Handling paths

Working directory

Getting and setting the working directory

Path manipulation

Reading from files

Reader interface

The file structure

Using buffers

Peeking content

Closer and seeker

Writing to file

Writer interface

Buffers and format

Efficient writing

File modes

Other operations

Create

Truncate

Delete

Move

Copy

Stats

Changing properties

Third-party packages

Virtual filesystems

Filesystem events

Summary

Questions

Handling Streams

Technical requirements

Streams

Input and readers

The bytes reader

The strings reader

Defining a reader

Output and writers

The bytes writer

The string writer

Defining a writer

Built-in utilities

Copying from one stream to another

Connected readers and writers

Extending readers

Writers and decorators

Summary

Questions

Building Pseudo-Terminals

Technical requirements

Understanding pseudo-terminals

Beginning with teletypes

Pseudo teletypes

Creating a basic PTY

Input management

Selector

Command execution

Some refactor

Improving the PTY

Multiline input

Providing color support to the pseudo-terminal

Suggesting commands

Extensible commands

Commands with status

Volatile status

Persistent status

Upgrading the Stack command

Summary

Questions

Section 3: Understanding Process Communication

Handling Processes and Daemons

Technical requirements

Understanding processes

Current process

Standard input

User and group ID

Working directory

Child processes

Accessing child properties

Standard input

Beginning with daemons

Operating system support

Daemons in action

Services

Creating a service

Third-party packages

Summary

Questions

Exit Codes, Signals, and Pipes

Technical requirements

Using exit codes

Sending exit codes

Exit codes in bash

The exit value bit size

Exit and deferred functions

Panics and exit codes

Exit codes and goroutines

Reading child process exit codes

Handling signals

Handling incoming signals

The signal package

Graceful shutdowns

Exit cleanup and resource release

Configuration reload

Sending signals to other processes

Connecting streams

Pipes

Anonymous pipes

Standard input and output pipes

Summary

Questions

Network Programming

Technical requirements

Communicating via networks

OSI model

Layer 1 – Physical layer

Layer 2 – Data link layer

Layer 3 – Network layer

Layer 4 – Transport layer

Layer 5 – Session layer

Layer 6 – Presentation layer

Layer 7 – Application layer

TCP/IP – Internet protocol suite

Layer 1 – Link layer

Layer 2 – Internet layer

Layer 3 – Transport layer

Layer 4 – Application layer

Understanding socket programming

Network package

TCP connections

UDP connections

Encoding and checksum

Web servers in Go

Web server

HTTP protocol

HTTP/2 and Go

Using the standard package

Making a HTTP request

Creating a simple server

Serving filesystem

Navigating through routes and methods

Multipart request and files

HTTPS

Third-party packages

gorilla/mux

gin-gonic/gin

Other functionalities

HTTP/2 Pusher

WebSockets protocol

Beginning with the template engine

Syntax and basic usage

Creating, parsing, and executing templates

Conditions and loops

Template functions

RPC servers

Defining a service

Creating the server

Creating the client

Summary

Questions

Data Encoding Using Go

Technical requirements

Understanding text-based encoding

CSV

Decoding values

Encoding values

Custom options

JSON

Field tags

Decoder

Encoder

Marshaler and unmarshaler

Interfaces

Generating structs

JSON schemas

XML

Structure

Document Type Definition

Decoding and encoding

Field tags

Marshaler and unmarshaler

Generating structs

YAML

Structure

Decoding and encoding

Learning about binary encoding

BSON

Encoding

Decoding

gob

Interfaces

Encoding

Decoding

Interfaces

Proto

Structure

Code generation

Encoding

Decoding

gRPC protocol

Summary

Questions

Section 4: Deep Dive into Concurrency

Dealing with Channels and Goroutines

Technical requirements

Understanding goroutines

Comparing threads and goroutines

Threads

Goroutines

New goroutine

Multiple goroutines

Argument evaluation

Synchronization

Exploring channels

Properties and operations

Capacity and size

Blocking operations

Closing channels

One-way channels

Waiting receiver

Special values

nil channels

Closed channels

Managing multiple operations

Default clause

Timers and tickers

Timers

AfterFunc

Tickers

Combining channels and goroutines

Rate limiter

Workers

Pool of workers

Semaphores

Summary

Questions

Synchronization with sync and atomic

Technical requirements

Synchronization primitives

Concurrent access and lockers

Mutex

RWMutex

Write starvation

Locking gotchas

Synchronizing goroutines

Singleton in Go

Once and Reset

Resource recycling

Slices recycling issues

Conditions

Synchronized maps

Semaphores

Atomic operations

Integer operations

clicker

Thread-safe floats

Thread-safe Boolean

Pointer operations

Value

Under the hood

Summary

Questions

Coordination Using Context

Technical requirements

Understanding context

The interface

Default contexts

Background

TODO

Cancellation, timeout, and deadline

Cancellation

Deadline

Timeout

Keys and values

Context in the standard library

HTTP requests

Passing scoped values

Request cancellation

HTTP server

Shutdown

Passing values

TCP dialing

Cancelling a connection

Database operations

Experimental packages

Context in your application

Things to avoid

Wrong types as keys

Passing parameters

Optional arguments

Globals

Building a service with Context

Main interface and usage

Exit and entry points

Exclude list

Handling directories

Checking file names and contents

Summary

Questions

Implementing Concurrency Patterns

Technical requirements

Beginning with generators

Avoiding leaks

Sequencing with pipelines

Muxing and demuxing

Fan-out

Fan-in

Producers and consumers

Multiple producers (N * 1)

Multiple consumers (1 * M)

Multiple consumers and producers (N*M)

Other patterns

Error groups

Leaky bucket

Sequencing

Summary

Questions

Section 5: A Guide to Using Reflection and CGO

Using Reflection

Technical requirements

What's reflection?

Type assertions

Interface assertion

Understanding basic mechanics

Value and Type methods

Kind

Value to interface

Manipulating values

Changing values

Creating new values

Handling complex types

Data structures

Changing fields

Using tags

Maps and slices

Maps

Slices

Functions

Analyzing a function

Invoking a function

Channels

Creating channels

Sending, receiving, and closing

Select statement

Reflecting on reflection

Performance cost

Usage in the standard library

Using reflection in a package

Property files

Using the package

Summary

Questions

Using CGO

Technical requirements

Introduction to CGO

Calling C code from Go

Calling Go code from C

The C and Go type systems

Strings and byte slices

Integers

Float types

Unsafe conversions

Editing a byte slice directly

Numbers

Working with slices

Working with structs

Structures in Go

Manual padding

Structures in C

Unpacked structures

Packed structures

CGO recommendations

Compilation and speed

Performance

Dependency from C

Summary

Questions

Assessments

Chapter 1

Chapter 2

Chapter 3

Chapter 4

Chapter 5

Chapter 6

Chapter 7

Chapter 8

Chapter 9

Chapter 10

Chapter 11

Chapter 12

Chapter 13

Chapter 14

Chapter 15

Chapter 16

Other Books You May Enjoy

Leave a review - let other readers know what you think