An Introduction to Golang

All you need to get started

It’s time to learn Golang. [Image source]

This post intends to be an introduction to the Go programming language, also known as Golang.

Disclaimer

I’m not an expert in Go. In fact, I’ve started learning about Go very recently. Therefore, take everything in this post with a pinch of salt.

Then… why am I writing a post about Go? It’s simple: I want to use this post as a tool to reinforce my learning process. I believe that working on a blog post and publishing it will force me to get every detail straight. Moreover, I’ll be crafting the guide that I would have liked to have found in the first place (and, therefore, it is likely that it will become the guide that you were looking for as well). This also means that this post will probably be evolving as I learn new aspects of Go.

Keep in mind, though, that despite of the fact that I’ll be working on every detail of the post, I may make mistakes. I encourage you to indicate in the comments section any errors that you may find, and I’ll gladly correct them.

If this disclaimer has let you down and you are not interested in reading this post anymore, here are some fantastic resources to get started with Go:

• A Tour of Go: Go’s official learning tour
• Golang learn: a list of community-driven learning resources
• FreeCodeCamp’s YT tutorial: a fantastic video of freeCodeCamp (6+ hours, no ads)

If you, however, decide to stay and keep reading… welcome!

A bit of history

Golang was born in Google, and it was created by Robert Griesemer, Rob Pike and Ken Thompson. It was discussed for the first time on September 21, 2007 and eventually became an open-source project on November 10, 2009.

As reported in Go’s site, this language was born due to the commonly necessary choice between an efficient compilation, efficient execution or ease of programming at the time of choosing a programming language to work with. Therefore, the main goal of Go was to create a language that would achieve the ease of an interpreted and dynamically typed language, while preserving the efficiency and safety of a statically typed, compiled language. Another one of the main goals was to take advantage of the growth of multicore CPUs, making concurrency one of the priorities of the language.

To get a deeper insight into the goals of Go, I’d recommend reading this article, written by Rob Pike. Some of the goals mentioned in this article include finding a solution for:

• slow builds
• uncontrolled dependencies
• each programmer using a different subset of the language
• poor program understanding (code hard to read, poorly documented, and so on)
• duplication of effort
• cost of updates
• version skew
• difficulty of writing automatic tools
• cross-language builds

Considering that Google works with large-scale systems that have huge codebases, Go was primarily developed as a language “in the service of software engineering”, attempting to solve the most common issues in large systems.

Getting started with Go

Setting up our development environment

In order to follow through this post, you have two options:

1. Set up a local development environment
2. Use Go’s official online playground

I will not go into the installation details for each platform, but here are some guides:

• Windows 10
• macOS
• Ubuntu 18.04

If you, however, prefer not to commit for now and test out the language, option 2 is a perfectly valid option. In any case, I recommend you to go through this introduction executing the examples, instead of just reading the code: I’m sure you would get a better grasp of the language.

Hello world!

Well, first things first! Let’s get started writing our first program in Go. In the following sections I’ll be explaining in more detail each part of our program. We may print our “Hello world!” message with the following few lines of code:

package main

import "fmt"
func main() {
  fmt.Println("Hello world!")
}

We’ll save the above snippet in a file called Main.go and then run the following instruction in our CLI:

go run Main.go

Voilà! If everything worked correctly, you should see our message printed in the terminal. Congrats! You’ve written your first Go program!

Let’s make an initial explanation of the above snippet, so that we start getting our first building blocks. Go programs are organized into packages, and one special package is “main”, which must be used in executable commands. We may now move towards the import statement, which allows us to include packages in our program. It may be worth mentioning that we may import multiple packages with the following syntax:

import (
  "<package_1>"
  "<package_2>"
)

In our example, we can see the “fmt” package, which is commonly used to read from stdin or write to stdout. We’ll be discovering this package in more detail as this article develops.

Finally, we may find the “func main()” declaration which, unsurprisingly, declares the main function of our Go program.

#software-engineering #go #golang #programming #software-development

What is GEEK

Buddha Community

Hire Dedicated Golang Developers | Golang Web Development Company

Does your business need a robust system across large-scale network servers then developing your app with a Golang programming language is the way to go. Golang is generally used for the development of highly secured, High Speed and High Modularity apps such as a FinTech Industry.

Want to develop a Highly secured app for your business?

Then hire a dedicated Golang developer from WebClues Infotech that are highly skilled in carrying out the work in a timely and qualitative output. With WebClues Infotech you get the assurance that we know what are the customers’ expectations and how to deliver on them on time.

Get your desired Golang Developer based on your project requirement!!

Share your requirements here https://www.webcluesinfotech.com/contact-us/

Book Free Interview with Golang developer: https://bit.ly/3dDShFg

#hire golang developer #hire go language developer #dedicated golang app developers #golang web development company #hire golang developers india #hire expert golang developers

Golang Web Development:Th Best Programming Language in 2020

https://www.mobinius.com/blogs/golang-web-development-company

#golang web development #golang-app-development-company #golang-development-solutions #hire-golang-developers #golang-development-services

Golang vs. Node.JS: Who Trumps the Battle of Backend Frameworks?

Full blog here

The backend of your application is truly the essential part of your product. No matter how much you appreciate the design, the application’s success lies in its backend. A scalable backend that effectively implements the required business logic is the primary goal of programmers.

Therefore, it is crucial to choose the most powerful and scalable technology. There are plenty of languages ​​in the market that can form the backend of any application, Node.js and Golang are the two most popular technologies among them.

They are real and developed languages ​​that have recently been used in various outstanding projects. Golang is an open-source programming language, whereas Node.js is an open-source server framework. They both are gaining popularity for various reasons.

According to a development stat, it is observed that almost 50% out of 58,543 respondents use Node.js as their preferred app development tool.

Golang, on the other hand, has overtaken other programming languages in the application development market and has gained huge recognition over the past few years.

But, which backend framework is best for you? In this article, I’ll make a healthy comparison of two of Google’s most popular backend development tools based on several essential features and various other factors.

Golang developers for hire

#best backend frameworks #node or golang #golang or nodejs #nodejs vs golang #golang vs nodejs #top backend frameworks

“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

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