Book Image

Go: Design Patterns for Real-World Projects

By : Vladimir Vivien, Mario Castro Contreras, Mat Ryer
Book Image

Go: Design Patterns for Real-World Projects

By: Vladimir Vivien, Mario Castro Contreras, Mat Ryer

Overview of this book

The Go programming language has firmly established itself as a favorite for building complex and scalable system applications. Go offers a direct and practical approach to programming that lets programmers write correct and predictable code using concurrency idioms and a full-featured standard library. This practical guide is full of real-world examples to help you get started with Go in no time at all. You’ll start by understanding the fundamentals of Go, then get a detailed description of the Go data types, program structures, and Maps. After that, you’ll learn how to use Go concurrency idioms to avoid pitfalls and create programs that are exact in expected behavior. Next, you will get familiar with the tools and libraries that are available in Go to write and exercise tests, benchmarking, and code coverage. After that, you will be able to utilize some of the most important features of GO such as Network Programming and OS integration to build efficient applications. Then you’ll start applying your skills to build some amazing projects in Go. You will learn to develop high-quality command-line tools that utilize the powerful shell capabilities and perform well using Go’s built-in concurrency mechanisms. Scale, performance, and high availability lie at the heart of our projects, and the lessons learned throughout the sections will arm you with everything you need to build world-class solutions. You will get a feel for app deployment using Docker and Google App Engine. Each project could form the basis of a start-up, which means they are directly applicable to modern software markets. With these skills in hand, you will be able to conquer all your fears of application development and go on to build large, robust and succinct apps in Go. This Learning Path combines some of the best that Packt has to offer in one complete, curated package. It includes content from the following Packt products: 1. Learning Go Programming 2. Go Design Patterns 3. Go Programming Blueprints, Second Edition

Related Content you might be interested in

Current Title:

Small book image
Go: Design Patterns for Real-World Projects
Vladimir Vivien | Mario Castro Contreras | Mat Ryer
Jun, 2017 | 18 hours 11 minutes
No titles found
Table of Contents (38 chapters)
Go: Design Patterns for Real-World Projects
Go: Design Patterns for Real-World Projects
Credits
Credits
Preface
Preface
Bibliography
Bibliography
Free Chapter
1
A First Step in Go
A First Step in Go
The Go programming language
Playing with Go
Your first Go program
Go in a nutshell
Summary
2
Go Language Essentials
Go Language Essentials
The Go source file
Go identifiers
Go variables
Go constants
Go operators
Summary
3
Go Control Flow
Go Control Flow
The if statement
Switch statements
The for statements
The break, continue, and goto statements
Summary
4
Data Types
Data Types
Go types
Numeric types
Boolean type
Rune and string types
Pointers
Type declaration
Type conversion
Summary
5
Functions in Go
Functions in Go
Go functions
Passing parameter values
Higher-order functions
Error signaling and handling
Deferring function calls
Function panic and recovery
Summary
6
Go Packages and Programs
Go Packages and Programs
The Go package
Creating packages
Building packages
Package visibility
Importing package
Package initialization
Creating programs
Remote packages
Summary
7
Composite Types
Composite Types
The array type
The slice type
The map type
The struct type
Summary
8
Methods, Interfaces, and Objects
Methods, Interfaces, and Objects
Go methods
Objects in Go
The interface type
Type assertion
Summary
9
Concurrency
Concurrency
Goroutines
Channels
Writing concurrent programs
The sync package
Detecting race conditions
Parallelism in Go
Summary
10
Data IO in Go
Data IO in Go
IO with readers and writers
The io.Reader interface
The io.Writer interface
Working with the io package
Working with files
Formatted IO with fmt
Buffered IO
In-memory IO
Encoding and decoding data
Summary
11
Writing Networked Services
Writing Networked Services
The net package
A TCP API server
The HTTP package
A JSON API server
Summary
12
Code Testing
Code Testing
The Go test tool
Writing Go tests
HTTP testing
Test coverage
Code benchmark
Summary
13
Ready... Steady... Go!
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
14
Creational Patterns - Singleton, Builder, Factory, Prototype, and Abstract Factory Design Patterns
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
15
Structural Patterns - Composite, Adapter, and Bridge Design Patterns
Structural Patterns - Composite, Adapter, and Bridge Design Patterns
Composite design pattern
Adapter design pattern
Bridge design pattern
Summary
16
Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns
Structural Patterns - Proxy, Facade, Decorator, and Flyweight Design Patterns
Proxy design pattern
Decorator design pattern
Facade design pattern
Flyweight design pattern
Summary
17
Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns
Behavioral Patterns - Strategy, Chain of Responsibility, and Command Design Patterns
Strategy design pattern
Chain of responsibility design pattern
Command design pattern
Summary
18
Behavioral Patterns - Template, Memento, and Interpreter Design Patterns
Behavioral Patterns - Template, Memento, and Interpreter Design Patterns
Template design pattern
Memento design pattern
Interpreter design pattern
Summary
19
Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns
Behavioral Patterns - Visitor, State, Mediator, and Observer Design Patterns
Visitor design pattern
State design pattern
Mediator design pattern
Observer design pattern
20
Introduction to Gos Concurrency
Introduction to Gos Concurrency
A little bit of history and theory
Goroutines
Callbacks
Mutexes
Channels
Using it all - concurrent singleton
Summary
21
Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns
Concurrency Patterns - Barrier, Future, and Pipeline Design Patterns
Barrier concurrency pattern
Future design pattern
Pipeline design pattern
Summary
22
Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns
Concurrency Patterns - Workers Pool and Publish/Subscriber Design Patterns
Workers pool
Concurrent Publish/Subscriber design pattern
Summary
23
Chat Application with Web Sockets
Chat Application with Web Sockets
A simple web server
Modeling a chat room and clients on the server
Building an HTML and JavaScript chat client
Tracing code to get a look under the hood
Summary
24
Adding User Accounts
Adding User Accounts
Handlers all the way down
Making a pretty social sign-in page
Endpoints with dynamic paths
Getting started with OAuth2
Tell the authorization providers about your app
Implementing external logging in
Summary
25
Three Ways to Implement Profile Pictures
Three Ways to Implement Profile Pictures
Avatars from the OAuth2 server
Implementing Gravatar
Uploading an avatar picture
Combining all three implementations
Summary
26
Command-Line Tools to Find Domain Names
Command-Line Tools to Find Domain Names
Pipe design for command-line tools
Five simple programs
Composing all five programs
Summary
27
Building Distributed Systems and Working with Flexible Data
Building Distributed Systems and Working with Flexible Data
The system design
Installing the environment
Reading votes from Twitter
Counting votes
Running our solution
Summary
28
Exposing Data and Functionality through a RESTful Data Web Service API
Exposing Data and Functionality through a RESTful Data Web Service API
RESTful API design
Sharing data between handlers
Wrapping handler functions
Injecting dependencies
Responding
Understanding the request
Serving our API with one function
Handling endpoints
A web client that consumes the API
Running the solution
Summary
29
Random Recommendations Web Service
Random Recommendations Web Service
The project overview
Representing data in code
Generating random recommendations
Summary
30
Filesystem Backup
Filesystem Backup
Solution design
The backup package
The user command-line tool
The daemon backup tool
Testing our solution
Summary
31
Building a Q&A Application for Google App Engine
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
32
Micro-services in Go with the Go kit Framework
Micro-services in Go with the Go kit Framework
Introducing gRPC
Protocol buffers
Building the service
Modeling method calls with requests and responses
An HTTP server in Go kit
A gRPC server in Go kit
Creating a server command
Building a gRPC client
Rate limiting with service middleware
Summary
33
Deploying Go Applications Using Docker
Deploying Go Applications Using Docker
Using Docker locally
Deploying Docker images
Deploying to Digital Ocean
Summary
Good Practices for a Stable Go Environment
Good Practices for a Stable Go Environment
Installing Go
Configuring Go
Go tools
Cleaning up, building, and running tests on save
Integrated developer environments
Summary

Variables and constants

Variables are spaces in computer's memory to store values that can be modified during the execution of the program. Variables and constants have a type like the ones described in preceding text. Although, you don't need to explicitly write the type of them (although you can do it). This property to avoid explicit type declaration is what is called Inferred types. For example:

    //Explicitly declaring a "string" variable 
    var explicit string = "Hello, I'm a explicitly declared variable"

Here we are declaring a variable (with the keyword var) called explicit of string type. At the same time, we are defining the value to Hello World!.

    //Implicitly declaring a "string". Type inferred 
inferred := ", I'm an inferred variable "

But here we are doing exactly the same thing. We have avoided the var keyword and the string type declaration. Internally, Go's compiler will infer (guess) the type of the variable to a string type. This way you have...

Previous Section
End of Section 7
Next Section