This is a creation in Article, where the information may have evolved or changed.
Basic syntax
The bible of the Go language
- Chapter One: Getting Started
- Helloworld
- Command-line arguments
- To find duplicate rows
- GIF animations
- Get URL
- Get multiple URLs concurrently
- Web Services
- Chapter II: Program Structure
- Named
- Statement
- Variable
- Assign value
- Type
- Packages and files
- Scope
- Chapter Three: Basic data types
- Integer
- Floating point number
- Plural
- Boolean type
- String
- Constant
- Fourth: Composite data types
- Array
- Slice (sliced)
- Map
- Structural body
- Json
- Text and HTML
- Fifth chapter: Functions
- function declaration
- Recursive
- Multiple return values
- Error
- function value
- anonymous functions
- Variable parameters
- Deferred function
- Panic exception
- Recover catching exceptions
- Sixth Chapter: Methods
- Method declaration
- A method based on a pointer object
- To extend a type by embedding a structure
- Method values and Method expressions
- Example: Bit array
- Packaging
- Seventh Chapter: interface
- Interface conventions
- Interface type
- Conditions for implementing an interface
- Flaq. Value interface
- Interface value
- Sort.interface interface
- http. Handler interface
- Error interface
- Example: evaluation of an expression
- Type assertion
- Distinguish error types based on type assertion
- Asking for behavior by type assertion
- Type switch
- Example: Tag-based XML decoding
- Eighth chapter: Goroutines and Channels
- Goroutines
- Example: Concurrent Clock Service
- Example: Example: concurrent echo Service
- Channels
- Concurrent Loops
- Example: a concurrent web crawler
- Multiple multiplexing based on select
- Example: Concurrent dictionary traversal
- Concurrent exit
- Example: Chat Service
- The Nineth chapter: concurrency based on shared variables
- Competitive conditions
- Sync. Mutex Mutex
- Sync. Rwmutex Read/write lock
- Memory synchronization
- Sync. Once initialization
- Competitive condition Detection
- Example: Concurrent, non-blocking cache
- Goroutines and threading
- Chapter Tenth: Packages and tools
- Package Introduction
- Import path
- Package Declaration
- Import claims
- Anonymous import of Packages
- Package and naming
- Tools
- The Tenth chapter: testing
- Go test
- Test function
- Test coverage
- Benchmark Test
- Analysis
- Example functions
- 12th Chapter: Reflection
- Why reflection is needed
- Reflect. Type and Reflect.value
- Display recursive printing
- Example: encoding S-expression
- Through reflect. Value Modify values
- Get struct Field ID
- Show a type of method set
- Some advice
- 13th: Bottom-level programming
- Unsafe. Sizeof, Alignof and Offsetof
- Unsafe. Pointer
- Example: depth equality judgment
- Calling C code through CGO
- Some advice
Network programming
"Nettwork Programming"
- System structure
- Protocol Layer
- Internet
- Gateway
- Data package
- Connection model
- Communication model
- Distributed communication model
- C/S system
- C/S Application
- Distributed service-side
- Traffic flow
- Distributed components
- Middleware model
- Durable processing
- Failed node
- Acceptance factors
- Transparency
- Eight misunderstandings of distributed computing
- Go language overview
- Type
- Multithreading
- Package
- Type conversions
- Statement
- Gopath
- Run Go Program
- Standard library
- Error value
- Chapter Three: Socket level programming
- TCP/IP stack
- Internet address
- IP Address Type
- Service
- TCP sockets
- Controlling TCP connections
- UDP datagram
- Services to monitor multiple sockets
- Conn, Packetconn, and listener types
- Original socket and Ipconn type
- Fourth chapter: Data serialization
- Structured data
- Mutual agreement
- Self-describing data
- Asn.1
- Json
- Gob bag
- Encode binary data into a string
- Protocol buffers
- Fifth Chapter: Application level Agreements
- Protocol Design
- Why should you be worried?
- Version control
- Message format
- Data format
- A simple example
- Status information
- Sixth chapter: Managing character sets and encodings
- Defined
- Ascii
- ISO 8859
- Unicode
- Utf-8,go, and runes.
- UTF-16 and go
- Unicode Cotchas
- ISO 8859 and Go
- Other character sets and go
- Seventh chapter: Security
- ISO Safety System
- Data integrity
- Symmetric key Encryption
- Public Key Cryptography
- Verification
- Eighth chapter: HTTP
- URLs and Resources
- Simple User Agent
- Configuring HTTP Requests
- Client Object
- Agent processing (proxy)
- HTTPS connection via Client
- Server
- HTTPS
- Nineth Chapter: Template
- Inserting object values
- Pipeline
- Defining functions
- Variable
- Conditional statements
- Html/template Bag
- The tenth chapter: a complete Web server
- Flowchart for browsing the site
- Browse files
- Base server
- Listflashcards function
- Manageflashcards function
- Chinese dictionary
- Flashcards Collection
- Resolving tones
- Listwords function
- Showflashcards function
- The display on the browser
- Run this server
- 11th Chapter: HTML
- Html/template Pack for Go language
- Tokenizing HTML
- Xhtml/html
- Json
- 12th Chapter: XML
- Parsing xml
- Unmarshalling XML
- Marshalling XML
- Xhtml
- Html
- The 13th chapter:
- Remote Process Call
- 14th Chapter: REST
- URIs and Resources
- Performance
- REST verbs
- No status
- Hypermedia (HATEOAS) applying the state engine
- Link representation
- Transactions with REST
- The Richardson maturity Model
- Flashcards Revisited
- The Demultiplexer (Demuxer)
- Content negotiation
- Handling Other URLs
- The Complete Server
- Client
- Using rest or RPC
- The 15th chapter: WebSocket
- WebSocket Server
- The Go sub-repository Package
- The Gorilla Package
Language skills
"Go in Practice"
- The first part: basic
- Chapter One: Going into go
- What is Go
- Notable places to go
- Multiple return values
- Modern Standard library
- Concurrency with Goroutines and channels
- Go tool chain: More than just a programming language
- Go in many languages
- C and Go
- Java and go
- Python, PHP, and go
- Javascript, node. js, and go
- Start running Go
- Hello, Go
- Chapter II: Fundamentals
- Command-line Programs
- Processing configuration
- Real-world Web services
- Chapter III: The Concurrency in Go
- Understanding the concurrency model of Go
- Using Goroutines
- Using channels
- The second part: Colorful application
- Fourth: Handling Error and panic
- Error handling
- Panic System
- Fifth chapter: Commissioning and Testing
- Locating bugs
- Log
- Access stack trace (stack trace)
- Test
- Performance testing
- Part III: Application interfaces
- Sixth chapter: HTML and email templates
- HTML templates
- Use templates for email
- Chapter Seventh: Services and receiving resources and forms
- Provide static content services
- Process form Requests
- Eighth chapter: Web Services
- REST APIs
- Passing and handling HTTP error
- Parsing and Mapping JSON
- API version Control
- Part IV: Application Cloud Deployment
- Nineth Chapter: Using Cloud Services
- What's a cloud?
- Manage Cloud services
- Run your program on a cloud server
- Tenth chapter: Communication between Cloud services
- Micro-service and highly available
- Inter-service communication
- 11th Chapter: Reflection and Code generation
- Three characteristics of a reflection
- Structs, tags, and annotations
- Generate go code with GO code
Web programming
"Go Web Programming"
- Part I: Go languages and Web Apps
- Chapter I: Go language and Web Apps
- developing Web Apps with Go
- web App How it works
- http Introduction
- the advent of Web Apps
- HTTP requests (Request)
- HTTP Responses (response)
- URIs
- HTTP/2 Introduction
- part of a web ' app
- Hello, Go
- Chapter Two: Go implementation chitchat
- let's talk.
- app design
- data Model
- receive and process requests
- generate HT from templates ML response
- install PostgreSQL
- Database Interface
- start server
- combo wrap up
- Part Two: Basic Web Application
- Chapter III: Handling Request
- Go net/http library
- Go service
- handlers and handler functions
- use HTTP/2
- Chapter Fourth: Processing request
- request and response
- HTML form and go
- responsewriter
- Cookies
- Fifth: Presentation content
- templates and template engine
- Go language template engine
- Action
- parameters, variables, and pipelines
- function
- Contextual Semantics
- Nested Templates
- use block actions to define templates
- Sixth: Storing data
- memory storage
- File Store
- go and SQL
- go and SQL Relationships
- Go relationship mapper
- Part III: The real World
- Seventh chapter: Go Web Services
- Introduction to Web Services
- SOAP-based Web services
- Rest-based Web services
- Using go to parse and create XML
- Use go to parse and create JSON
- Create a Go Web service
- Eighth: Test Your application
- Go and test
- Go Unit Test
- Go HTTP Test
- Test repeat and Dependency injection
- Third-party Go test library
- The Nineth chapter: Using Go concurrency
- Concurrency is not parallel
- Goroutines
- Channels
- Using Concurrency in Web applications
- Tenth: Deploy the Go app
- Deploy to Server
- Deploy to Heroku
- Deploy to Google APP Engine
- Deploy to Docker
- Comparison of different deployment methods
Select: Distributed System
MIT Distributed Systems Course
