Go (Golang) — A Quick Overview

While reviewing one of the job descriptions I’ve come across a coding language that got my attention. Go — I knew about  the game Go, but never heard anything about coding language by that name. I knew that Go (game) is very complex, and requires strategic thinking and great focus.

Well, it turns out Google designed Go (programming language) in 2007 and released it in 2012. I was curious to learn more about this language, so here is a quick overview of my findings. It’s also called Golang, because its website is  https://golang.org/. It’s a great resource to learn more about this language since they have:

• interactive tour —  https://tour.golang.org
• Video tour —  https://research.swtch.com/gotour
• Tutorials —  https://golang.org/doc/tutorial/
• and more.

#go #golang

What is GEEK

Buddha Community

What's new in the go 1.15

Go announced Go 1.15 version on 11 Aug 2020. Highlighted updates and features include Substantial improvements to the Go linker, Improved allocation for small objects at high core counts, X.509 CommonName deprecation, GOPROXY supports skipping proxies that return errors, New embedded tzdata package, Several Core Library improvements and more.

As Go promise for maintaining backward compatibility. After upgrading to the latest Go 1.15 version, almost all existing Golang applications or programs continue to compile and run as older Golang version.

#go #golang #go 1.15 #go features #go improvement #go package #go new features

Go-web-workshop: Build Web Applications with Go on App Engine

Building Web Applications with Go

Welcome, gopher! You're not a gopher? Well, this workshop is for gophers, or people that use the Go programming language. But fear not if you've never written any Go before! I'd recommend you learn the basics for the language first with the Go tour.

This workshop has been run a couple of times with an instructor leading. The goal of this repo is to make it as easy as possible for individuals to follow the content by themselves. If you get stuck at any point, feel free to file issues asking questions.

Setting up your workspace

To go through this you will need the following:

1. You have installed the Go Programming Language.
2. You have set up a GOPATH by following the How to Write Go Code tutorial.
3. You are somewhat familiar with the basics of Go. (The Go Tour is a pretty good place to start)
4. You have a Google account and you have installed the Google Cloud SDK.

Contents

There's a lot to say about how to build web applications, in Go or any other language. But we only have one day so we won't try to cover too much. Instead we'll cover the basics, so you'll be able to explore other solutions and frameworks later.

The workshops is divided in eleven sections:

• 0: Hello world
• 1: Web Clients
• 2: Web servers
• 3: Input validation and status codes
• 4: Deploying to App Engine
• 5: Hello, HTML
• 6: JSON encoding and decoding
• 7: Durable storage with Cloud Datastore
• 8: Retrieving remote resources with urlfetch
• 9: What is Memcache and how to use it from App Engine
• 10: Congratulations!

Resources

These are places where you can find more information for Go:

• golang.org
• godoc.org, where you can find the documentation for any package.
• The Go Programming Language Blog

My favorite aspect of Go is its community, and you are now part of it too. Welcome!

As a newcomer to the Go community you might have questions or get blocked at some point. This is completely normal, and we're here to help you. Some of the places where gophers tend to hang out are:

• The Go Forum
• #go-nuts IRC channel at Freenode
• Gophers’ community on Slack (signup here for an account).
• @golang and #golang on Twitter.
• Go+ community on Google Plus.
• Go user meetups
• golang-nuts mailing list
• Go community Wiki

Disclaimer

This is not an official Google product (experimental or otherwise), it is just code that happens to be owned by Google.

Author: Campoy
Source Code: https://github.com/campoy/go-web-workshop 
License: Apache-2.0 license

#go #golang #web 

“Go Has Indeed Become The Language Of Cloud Infrastructure“ - Rob Pike

Introduction

We spoke to Rob Pike, the co-author of the Go programming language, about a career spanning four decades, the evolution of Go over the last ten years, and into the future.

The Interview

Evrone: Unlike many developers today, you started your career decades ago at Bell Labs. What’s been the biggest change in the way we develop software that you can think of, given your rare perspective?

**Rob: **The scale is much bigger today. Not just of the computers and the network, but the programs themselves. All of Unix version 6 (circa 1975) fits comfortably on a single RK05 disk pack, which has just over 2MB of storage, with lots of room left over for user software. And that was a fine computing environment, or at least seemed like one at the time. Although I can, of course, explain much of the growth, it is astonishing and perhaps not all of it is justified.

#golang #golang-api #golang-tools #golang-website #rob-pike #interview-transcript-go #latest-tech-stories #cloud-infrastructure-and-go

Secure HTTPS servers in Go

In this article, we are going to look at some of the basic APIs of the http package to create and initialize HTTPS servers in Go.

(source: unsplash.com)

In the “Simple Hello World Server” lesson, we learned about net/http package, how to create routes and how [ServeMux](https://golang.org/pkg/net/http/#ServeMux) works. In the “Running multiple HTTP servers” lesson, we learned about [Server](https://golang.org/pkg/net/http/#Server) structure and how to run multiple HTTP servers concurrently.

In this lesson, we are going to create an HTTPS server using both Go’s standard server configuration and custom configuration (using [_Server_](https://golang.org/pkg/net/http/#Server) structure). But before this, we need to know what HTTPS really is?

HTTPS is a big topic of discussion in itself. Hence while writing this lesson, I published an article just on “How HTTPS works?”. I advise you to read this lesson first before continuing this article. In this article, I’ve also described the encryption paradigm and SSL certificates generation process.

---

If we recall the simplest HTTP server example from previous lessons, we only need http.``[ListenAndServe](https://golang.org/pkg/net/http/#ListenAndServe) function to start an HTTP server and http.``[HandleFunc](https://golang.org/pkg/net/http/#HandleFunc) to register a response handler for a particular endpoint.

(https://play.golang.org/p/t3sOenOYAzS)

In the example above, when we run the command go run server.go , it will start an HTTP server on port 9000. By visiting http://localhost:9000 URL in a browser, you will be able to see a Hello World! message on the screen.

(http://localhost:9000)

As we know, the nil argument to ListenAndServe() call invokes Go to use the [DefaultServeMux](https://golang.org/pkg/net/http/#DefaultServeMux) response multiplexer, which is the default instance of ServeMux structure provided globally by the Go. The HandleFunc() call adds a response handler for a specific route on the multiplexer instance.

The http.ListenAndServe() call uses the Go’s standard HTTP server configuration, however, in the previous lesson, how we can customize a server using [Server](https://golang.org/pkg/net/http/#Server) structure type.

To start an HTTPS server, all we need do is to call ServerAndListenTLS method with some configuration. Just like ServeAndListen method, this method is available on both the http package and the Server structure.

The http.``[ServeAndListenTLS](https://golang.org/pkg/net/http/#ListenAndServeTLS) method uses the Go’s standard server implementation, however, both [Server](https://golang.org/pkg/net/http/#Server) instance and Server.``[ServeAndListenTLS](https://golang.org/pkg/net/http/#Server.ListenAndServeTLS) method can be configured for our needs.

#go-programming-language #go #golang-tutorial #go-programming #golang

Gopher-reading-list: A Curated Selection Of Blog Posts on Go

Gopher Reading List

中文版

Here is a reading list of blog posts about Go. It aspires to include only the most useful and relevant material that anyone writing Go should eventually read. By definition, the list is a work in progress.

Rather than being comprehensive, the list is a curated selection fixed at 200 entries.

Go is growing fast and so are the number of blog posts about it. If an interested reader knows of a great post not on this list, please open an issue with a link to the post. Not every blog post linked in an issue will make its way into the list. Nonetheless, the issue list (both open and closed) is a good source of additional reading material.

NOTE: Any new additions will need to replace something else on the list to keep it at a fixed length.

Start Here

• Why should you learn Go?
• An Intro to Go for non-Go developers
• How to Write Go Code
• A Tour of Go
• Frequently Asked Questions
• Go by Example
• Go 101

See Go Books for a list of books, both free and paid.

Beginner

Some basics

• Understand Go pointers in less than 800 words or your money back
• Don't fear the pointer
• Channel Axioms
• Golang channels tutorial
• Common Gotchas in Go
• 50 Shades of Go: Traps, Gotchas, and Common Mistakes for New Golang Devs
• Slices from the ground up
• 6 Tips for Using Strings in Go
• Go Defer Simplified with Practical Visuals
• How to Use Go Interfaces
• Different Ways to Initialize Go structs

Worth reading, again and again

• Effective Go
• Visualizing Concurrency in Go
• Strings, bytes, runes and characters in Go
• Arrays, slices (and strings): The mechanics of 'append'

Organization and Style

• Practical Go: Real world advice for writing maintainable Go programs
• Less is exponentially more
• Go Proverbs
• Code Review Comments
• Idiomatic Go
• Error handling and Go
• Go's Error Handling is Elegant
• Working with Errors in Go 1.13
• Simple Go project layout with modules
• Structuring Tests in Go
• Standard Package Layout
• Packages as layers, not groups
• Structuring Applications in Go
• Style guideline for Go packages
• Package names

Web

• Creating My First Web Application with Go
• Making a RESTful JSON API in Go
• Serving Static Sites with Go
• An Intro To Templates in Go
• JSON APIs Are Just Web Applications
• Writing middleware in #golang and how Go makes it so much fun
• Go and JSON
• Accessing data in Go
• How to Use //go:embed

Concurrency

• Learning Go's Concurrency Through Illustrations
• Go’s append is not always thread safe

Go Modules

• Introduction to Go modules
• Using Go Modules
• Modules Part 01: Why And What

Intermediate

Code Design

• Go best practices, six years in
• Aspects of a good Go library
• Solid Go Design
• Go for Industrial Programming
• Why you shouldn't use func main in Go
• Failure is your Domain
• What “accept interfaces, return structs” means in Go
• Pitfalls of context values and how to avoid or mitigate them in Go
• How to organize the go struct, in order to save memory
• Loose Coupling in Go lang
• Self-referential functions and the design of options
• Functional Options for Friendly APIs
• Functional Options on Steroids
• Object Oriented Inheritance in Go
• Error handling in Upspin

Concurrency

• Concurrency Patterns
• Stopping goroutines
• Make Ctrl+C cancel the context.Context
• How to correctly use context.Context in Go 1.7
• Using contexts to avoid leaking goroutines
• Go Concurrency Patterns: Pipelines and cancellation
• Tutorial: Synchronizing State with Mutexes in Go
• Context and Cancellation of goroutines
• Dancing with Go's Mutexes
• GoRoutines, Channels, and Proper Exits
• How to Block Forever in Go
• Mutex Profile
• Sane Concurrency with Go
• Error handling patterns in Go
• Does the race detector catch all data races?
• Interesting ways of using Go channels
• The underutilized usefulness of sync.Once
• Code Review Checklist: Go concurrency
• The Pros of Conds

Testing

• Testing Web Apps in Go
• An Introduction to Testing in Go
• 5 simple tips and tricks for writing unit tests in #golang
• 5 Advanced Testing Techniques in Go
• Interfaces and Composition for Effective Unit Testing in Golang
• Go Testing Technique: Testing JSON HTTP Requests
• Acceptance Testing Go Web Applications with Cookies
• Testing Your (HTTP) Handlers in Go
• Learn Go with tests
• Lesser-Known Features of Go Test
• When Writing Unit Tests, Don’t Use Mocks

Web

• Go for Cloud
• Exposing Go on the Internet
• The complete guide to Go net/http timeouts
• HTTP(S) Proxy in Golang in less than 100 lines of code
• Write a Kubernetes-ready service from zero step-by-step
• A brief intro of TCP keep-alive in Go’s HTTP implementation
• Go JSON Cookbook
• Build a Web Crawler in Go
• Your pprof is showing: IPv4 scans reveal exposed net/http/pprof endpoints:
• HTTP Request Contexts & Go
• Using Object-Oriented Web Servers in Go
• Handle HTTP Request Errors in Go
• Go json.Decoder Considered Harmful
• Building High Performance APIs In Go Using gRPC And Protocol Buffers
• Don't use Go's default HTTP client (in production)
• Writing an API Client in Go
• Seeking around in an HTTP object
• Using Functions Inside Go Templates
• Writing a Data Mapper in Go without an ORM
• Practical Persistence in Go: Organising Database Access
• How I write Go HTTP services after seven years
• Make resilient Go net/http servers using timeouts, deadlines and context cancellation
• Life of an HTTP request in a Go server
• Gotchas in the Go Network Packages Defaults
• Graceful shutdown of a TCP server in Go

Tools

• An Overview of Go's Tooling
• Go tooling essentials
• Profiling Go Programs
• Go Tooling in Action
• Statically compiling Go programs

Trivia

• 10 things you (probably) don't know about Go
• Advanced Go Tips And Tricks
• Golang slices gotcha

Diagnostics

• Diagnostics
• Profiling Go
• Five things that make Go fast
• Debugging Go Applications using Delve

Language

• Golang: pass by pointer vs pass by value
• There is no pass-by-reference in Go
• Variadic functions in Go
• Function Types in Go (golang)
• research!rsc: Go Data Structures
• The Relationship Between Interfaces and Reflection
• When to Use Generics in Go?
• An Introduction to Generics

Miscellaneous

• Always Be Closing
• Don't defer Close() on writable files
• How to Use go:generate
• Writing worker queues, in Go
• Job Queues in Go - OpsDash
• Reading files in Go
• Vanity Go Import Paths
• Tags in Golang
• Handling Errors from Deferred Functions in Go
• Why Go modules are faster than GOPATH

Advanced

Low Level Concerns

• The Go Memory Model
• Go's work-stealing scheduler
• The Go scheduler
• Illustrated Tales of Go Runtime Scheduler
• Go: Asynchronous Preemption
• Go Assembly by Example
• Address Alignments in Go
• Hacking the Scheduler
• Scheduling In Go - Part II
• Anatomy of a function call in Go
• Scheduler Tracing in Go
• unsafe.Pointer and system calls
• Type-Unsafe Pointers
• Looking at your program’s structure in Go 1.7
• Managing Syscall Overhead with crypto/rand
• Optimized abs() for int64 in Go
• Go: Introduction to the Escape Analysis

Performance

• Allocation Efficiency in High-Performance Go Services
• Handling 1 Million Requests per Minute with Go
• Go code refactoring : the 23x performance hunt
• A Million WebSockets and Go
• go-perfbook
• Simple techniques to optimise Go programs
• High Performance Go Workshop
• Reducing Memory Allocations in Golang

Garbage Collection

• Getting to Go: The Journey of Go's Garbage Collector
• Avoiding high GC overhead with large heaps
• Golang's Real-time GC in Theory and Practice
• How to Optimize Garbage Collection in Go
• Garbage Collection in Go

Concurrency

• Advanced Go Concurrency Patterns
• The X-Files: Avoiding Concurrency Boilerplate with golang.org/x/sync
• Golang lock-free values with atomic.Value
• Share Memory by Communicating
• Concurrency is not parallelism
• Go Concurrency Patterns: Context
• Go Concurrency Patterns: Timing out, moving on
• Concurrency, Goroutines and GOMAXPROCS
• Locking in crypto/rand
• Stateful locks in Go

JSON Encoding and Decoding

• Advanced Encoding and Decoding Techniques
• Custom JSON Marshalling in Go

Miscellaneous

• Text normalization in Go
• Minimal Perfect Hash Functions
• Go Experience Report for Generics: Google metrics API
• go-internals
• go-fuzz github.com/arolek/ase
• Property-based testing in Go
• Monkey Patching in Go

Download Details:

Author: Enocom
Source Code: https://github.com/enocom/gopher-reading-list 
License: Apache-2.0 license

#go #golang #reading