book

Go: Building Web Applications

by Nathan Kozyra, Mat Ryer

August 2016

Beginner to intermediate

665 pages

14h 11m

English

Packt Publishing

Read now

Unlock full access

What this learning path covers
Downloading the example codeErrataPiracyQuestions

Installing Go
Code conventions
Handling private repositoriesDealing with versioning
Serving files directly
Connecting to a databaseCreating a MySQL database
Introducing templates, context, and visibility
Setting up the basic API endpoint
Setting cookies
Creating usersEnabling sessionsLetting users registerLetting users log in
Creating a storeUtilizing flash messages
Introducing the microservice approach
Introducing logging in Go
Multiple loggers
HTTPS everywhere – implementing TLS
Identifying bottlenecks
Using Least Recently UsedCaching by fileCaching in memory
A simple web serverTemplatesDoing things onceUsing your own handlersProperly building and executing Go programs
Modeling the clientModeling a roomConcurrency programming using idiomatic GoTurning a room into an HTTP handlerUse helper functions to remove complexityCreating and using rooms
Getting more out of templates
Writing a package using TDDInterfacesUnit testsRed-green testingImplementing the interfaceUnexported types being returned to usersUsing our new trace packageMaking tracing optionalClean package APIs
Handlers all the way down
Open source OAuth2 packages
Logging inHandling the response from the providerPresenting the user dataAugmenting messages with additional data
Avatars from the authentication serverGetting the avatar URLTransmitting the avatar URLAdding the avatar to the user interfaceLogging outMaking things prettier
Abstracting the avatar URL processThe authentication service and avatar's implementationUsing an implementationGravatar implementation
User identificationAn upload formHandling the uploadServing the imagesThe Avatar implementation for local filesSupporting different file typesRefactoring and optimizing our codeReplacing concrete types with interfacesChanging interfaces in a test-driven wayFixing existing implementationsGlobal variables versus fieldsImplementing our new designTidying up and testing
Pipe design for command-line tools
SprinkleExercise – configurable transformationsDomainifyExercise – making top-level domains configurableCoolifySynonymsUsing environment variables for configurationConsuming a web APIGetting domain suggestionsAvailable
One program to rule them all
System designDatabase design
NSQNSQ driver for GoMongoDBMongoDB driver for GoStarting the environment
Authorization with TwitterExtracting the connectionReading environment variablesReading from MongoDBReading from TwitterSignal channelsPublishing to NSQGracefully starting and stoppingTesting
Connecting to the databaseConsuming messages in NSQKeeping the database updatedResponding to Ctrl + C
RESTful API design
API keyDatabase sessionPer request variablesCross-browser resource sharing
Using handler function wrappers
Using tags to add metadata to structsMany operations with a single handlerReading pollsCreating a pollDeleting a pollCORS supportTesting our API using curl
An index page showing a list of pollsA page to create a new pollA page to show details of the poll
Project overviewProject design specifics
Public views of Go structs
Google Places API keyEnumerators in GoTest-driven enumeratorQuerying the Google Places APIBuilding recommendationsHandlers that use query parametersCORSTesting our APIWeb application
Solution designProject structure
Obvious interfaces?Implementing ZIPHas the filesystem changed?Checking for changes and initiating a backupHardcoding is OK for a short while
Persisting small dataParsing argumentsListing the pathsString representations for your own typesAdding pathsRemoving pathsUsing our new tool
Duplicated structuresCaching dataInfinite loopsUpdating filedb records
Introducing goroutinesA patient goroutine
Using Go's schedulerUsing system variables
Channel-based sorting at the letter capitalization factoryCleaning up our goroutinesBuffered or unbuffered channelsUsing the select statement
Understanding the working of goroutines
Designing the web server plan
An RSS reader with self diagnosticsImposing a timeout
The dining philosophers problem
Demonstrating simple polymorphism in Go
Applying efficiency in complex concurrency
Using mutual exclusionsExploring timeoutsImportance of consistency
Visualizing a concurrent patternDeveloping our server requirementsWeb serverThe Gorilla toolkitUsing templatesTimeEndpointsCustom structs
Getting deeper with mutexes and sync
Touching memory in cgoThe structure of cgoThe other way aroundGetting even lower – assembly in Go
Distributed shared memoryFirst-in-first-out – PRAMLooking at the master-slave modelThe producer-consumer problemLooking at the leader-follower modelAtomic consistency / mutual exclusionRelease consistency
Circuit
Understanding blocking methods in GoBlocking method 1 – a listening, waiting channelSending more data types via channelsCreating a function channelUsing an interface channelUsing structs, interfaces, and more complex channelsThe net package – a chat server with interfaced channelsHandling direct messagesExamining our clientBlocking method 2 – the select statement in a loop
Blocking method 3 – network connections and reads
Attacking the C10K problemFailing of servers at 10,000 concurrent connectionsUsing concurrency to attack C10KTaking another approach
Benchmarking against a blocking web serverHandling requestsRouting requests
Parsing our templateExternal dependenciesConnecting to MySQL
Timing out and moving on
High performance in GoGetting deeper into pprofParallelism's and concurrency's impact on I/O pprof
Types of topologiesType 1 – starType 2 – meshThe Publish and Subscribe modelSerialized dataRemote code executionOther topologiesMessage Passing Interface
Nitro profilerHekaGoFlow
Garbage collection in Go
Designing our concurrent application
MongoDBRedisTiedotCouchDBCassandraCouchbaseSetting up our data store
Sending changes to clientsChecking records against Couchbase
Using Go in daemons and as a service
Handling errors and loggingBreaking out goroutine logsUsing the LiteIDE for richer and easier debuggingSending errors to screenLogging errors to fileLogging errors to memory
PanickingRecoveringLogging our panicsCatching stack traces with concurrent code
Going beyond the basics with channels
Using nil channels
Using receive-only or send-only channels
GoCheckGinkgo and Gomega
Structuring your codeDocumenting your codeMaking your code available via go getKeeping concurrency out of your packages

Content preview from Go: Building Web Applications

Five simple programs

In this chapter, we will build five small programs that we will combine together at the end. The key features of the programs are as follows:

Sprinkle: This program will add some web-friendly sprinkle words to increase the chances of finding available domain names
Domainify: This program will ensure words are acceptable for a domain name by removing unacceptable characters and replacing spaces with hyphens and adding an appropriate top-level domain (such as .com and .net) to the end
Coolify: This program will make a boring old normal word into Web 2.0 by fiddling around with vowels
Synonyms: This program will use a third-party API to find synonyms
Available: This program will check to see whether the domain is available or not ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Start your free trial

Hands-On Full Stack Development with Go

Mina Andrawos

Building and leveraging REST APIs with Go

Aaron Schlesinger

Building full-stack web applications with Go

Aaron Schlesinger

Hands-On RESTful Web Services with Go - Second Edition

Naren Yellavula

Publisher Resources

ISBN: 9781787123496