1. A First Step in Go
by Mat Ryer, Mario Castro Contreras, Vladimir Vivien
Go: Design Patterns for Real-World Projects
- Go: Design Patterns for Real-World Projects
- Go: Design Patterns for Real-World Projects
- Credits
- Preface
- 1. Module 1
- 1. A First Step in Go
- 2. Go Language Essentials
- 3. Go Control Flow
- 4. Data Types
- 5. Functions in Go
- 6. Go Packages and Programs
- 7. Composite Types
- 8. Methods, Interfaces, and Objects
- 9. Concurrency
- 10. Data IO in Go
- 11. Writing Networked Services
- 12. Code Testing
- 2. Module 2
- 1. Ready... Steady... Go!
- A little bit of history
- Installing Go
- Starting with Hello World
- Integrated Development Environment - IDE
- Types
- Variables and constants
- Operators
- Flow control
- Functions
- Arrays, slices, and maps
- Visibility
- Zero-initialization
- Pointers and structures
- Interfaces
- Testing and TDD
- Libraries
- The Go get tool
- Managing JSON data
- Go tools
- Contributing to Go open source projects in GitHub
- Summary
- 2. Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns
- Singleton design pattern - having a unique instance of a type in the entire program
- Builder design pattern - reusing an algorithm to create many implementations of an interface
- Factory method - delegating the creation of different types of payments
- Abstract Factory - a factory of factories
- Prototype design pattern
- Summary
- 3. Structural Patterns - Composite, Adapter, and Bridge Design Patterns
- 4. Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns
- 5. Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns
- 6. Behavioral Patterns - Template, Memento, and Interpreter Design Patterns
- Template design pattern
- Description
- Objectives
- Example - a simple algorithm with a deferred step
- Requirements and acceptance criteria
- Unit tests for the simple algorithm
- Implementing the Template pattern
- Anonymous functions
- How to avoid modifications on the interface
- Looking for the Template pattern in Go's source code
- Summarizing the Template design pattern
- Memento design pattern
- Interpreter design pattern
- Summary
- Template design pattern
- 7. Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns
- 8. Introduction to Gos Concurrency
- 9. Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns
- 10. Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns
- 1. Ready... Steady... Go!
- 3. Module 3
- 1. Chat Application with Web Sockets
- 2. Adding User Accounts
- 3. Three Ways to Implement Profile Pictures
- 4. Command-Line Tools to Find Domain Names
- 5. Building Distributed Systems and Working with Flexible Data
- 6. Exposing Data and Functionality through a RESTful Data Web Service API
- 7. Random Recommendations Web Service
- 8. Filesystem Backup
- 9. Building a Q&A Application for Google App Engine
- The Google App Engine SDK for Go
- Google Cloud Datastore
- Entities and data access
- Google App Engine users
- Transactions in Google Cloud Datastore
- Querying in Google Cloud Datastore
- Votes
- Casting a vote
- Exposing data operations over HTTP
- Running apps with multiple modules
- Deploying apps with multiple modules
- Summary
- 10. Micro-services in Go with the Go kit Framework
- 11. Deploying Go Applications Using Docker
- Appendix. Good Practices for a Stable Go Environment
- Bibliography
In the first chapter of the book, you will be introduced to Go and take a tour of the features that have made the language a favorite among its adopters. The start of the chapter provides the motivation behind the Go programming language. If you are impatient, however, you are welcome to skip to any of the other topics and learn how to write your first Go program. Finally, the Go in a nutshell section provides a high-level summary of the characteristics of the language.
The following topics are covered in this chapter:
- The Go programming language
- Playing with Go
- Installing Go
- Your first Go program
- Go in a nutshell
Since the invention of the C language in the early 1970s by Dennis Ritchie at Bell Labs, the computing industry has produced many popular languages that are based directly on (or have borrowed ideas from) its syntax. Commonly known as the C-family of languages, they can be split into two broad evolutionary branches. In one branch, derivatives such as C++, C#, and Java have evolved to adopt a strong type system, object orientation, and the use of compiled binaries. These languages, however, tend to have a slow build-deploy cycle and programmers are forced to adopt a complex object-oriented type system to attain runtime safety and speed of execution:
In the other evolutionary linguistic branch are languages such as Perl, Python, and JavaScript that are described as dynamic languages for their lack of type safety formalities, use of lightweight scripting syntax, and code interpretation instead of compilation. Dynamic languages have become the preferred tool for web and cloud scale development where speed and ease of deployment are valued over runtime safety. The interpreted nature of dynamic languages means, however, they generally run slower than their compiled counterparts. In addition, the lack of type safety at runtime means the correctness of the system scales poorly as the application grows.
Go was created as a system language at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thomson to handle the needs of application development. The designers of Go wanted to mitigate the issues with the aforementioned languages while creating a new language that is simple, safe, consistent, and predictable. As Rob Pike puts it:
"Go is an attempt to combine the safety and performance of a statically-typed language with the expressiveness and convenience of a dynamically-typed interpreted language."
Go borrows ideas from different languages that came before it, including:
- Simplified but concise syntax that is fun and easy to use
- A type of system that feels more like a dynamic language
- Support for object-oriented programming
- Statically typed for compilation and runtime safety
- Compiled to native binaries for fast runtime execution
- Near-zero compilation time that feels more like an interpreted language
- A simple concurrency idiom to leverage multi-core, multi-chip machines
- A garbage collector for safe and automatic memory management
The remainder of this chapter will walk you through an introductory set of steps that will give you a preview of the language and get you started with building and running your first Go program. It is a precursor to the topics that are covered in detail in the remaining chapters of the book. You are welcome to skip to other chapters if you already have a basic understanding of Go.
-
No Comment