Hands-On System Programming with Go
Alex Guerrieri更新时间：2021-06-24 13:43:27
最新章节：Leave a review - let other readers know what you thinkcoverpage
Title Page
Copyright and Credits
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
更新时间：2021-06-24 13:43:27