Digital Library

The Way To Go A Thorough Introduction To The Go Programming Language (Ivo Balbaert)（Z-Library）

Share E-Book
Read Without Registration

The Way To Go A Thorough Introduction To The Go Programming Language (Ivo Balbaert)（Z-Library）

Author

Rating No ratings yet

Log in to rate

Go
Language English

This book provides the reader with a comprehensive overview of the new open source programming language Go (in its first stable and maintained release Go 1) from Google. The language is devised with Java / C#-like syntax so as to feel familiar to the bulk of programmers today, but Go code is much cleaner and simpler to read, thus increasing the productivity of developers. You will see how Go: simplifies programming with slices, maps, structs and interfaces incorporates functional programming makes error-handling easy and securesimplifies concurrent and parallel programming with goroutines and channelsAnd you will learn how to: make use of Gos excellent standard library program Go the idiomatic way using patterns and best practices in over 225 working examples and 135 exercises This book focuses on the aspects that the reader needs to take part in the coming software revolution using Go.

Format PDF
Size 4.9 MB
211
Views
(First 20 pages)

Registered users can read the full content for free

Register as a Gaohf Library member to read the complete e-book online for free and enjoy a better reading experience.

Page 1
THE WAY TO GO IVO BALBAERT A Thorough Introduction to the Go Programming Language
Page 2
The Way To Go
Page 3
Also by Ivo Balbaert: “Handboek Programmeren met Ruby en Rails.”, 2009, Van Duuren Media, ISBN: 978-90-5940-365-9
Page 4
The Way To Go a Thorough Introduction to the Go Programming Language Ivo BaLBaerT iUniverse, Inc. Bloomington
Page 5
The Way to Go A Thorough Introduction to the Go Programming Language Copyright © 2012 by Ivo Balbaert. All rights reserved. No part of this book may be used or reproduced by any means, graphic, electronic, or mechanical, including photocopying, recording, taping or by any information storage retrieval system without the written permission of the publisher except in the case of brief quotations embodied in critical articles and reviews. iUniverse books may be ordered through booksellers or by contacting: iUniverse 1663 Liberty Drive Bloomington, IN 47403 www.iuniverse.com 1-800-Authors (1-800-288-4677) Because of the dynamic nature of the Internet, any web addresses or links contained in this book may have changed since publication and may no longer be valid. The views expressed in this work are solely those of the author and do not necessarily reflect the views of the publisher, and the publisher hereby disclaims any responsibility for them. Any people depicted in stock imagery provided by Thinkstock are models, and such images are being used for illustrative purposes only. Certain stock imagery © Thinkstock. ISBN: 978-1-4697-6916-5 (sc) ISBN: 978-1-4697-6917-2 (ebk) Printed in the United States of America iUniverse rev. date: 03/05/2012
Page 6
ConTenTs Preface ................................................................................................................................ xix PART 1—WHY LEARN GO—GETTING STARTED Chapter 1—Origins, Context and Popularity of Go ..............................................................1 1.1 Origins and evolution ...............................................................................................1 1.2 Main characteristics, context and reasons for developing a new language ...................4 1.2.1 Languages that influenced Go ........................................................................4 1.2.2 Why a new language? .....................................................................................5 1.2.3 Targets of the language ...................................................................................5 1.2.4 Guiding design principles ..............................................................................7 1.2.5 Characteristics of the language .......................................................................7 1.2.6 Uses of the language .......................................................................................8 1.2.7 Missing features? ............................................................................................9 1.2.8 Programming in Go .....................................................................................10 1.2.9 Summary .....................................................................................................10 Chapter 2—Installation and Runtime Environment ...........................................................11 2.1 Platforms and architectures ....................................................................................11 (1) The gc Go-compilers: .................................................................................11 (2) The gccgo-compiler: ...................................................................................13 (3) File extensions and packages: ......................................................................14 2.2 Go Environment variables .......................................................................................14 2.3 Installing Go on a Linux system ..............................................................................16 2.4 Installing Go on an OS X system ............................................................................21 2.5 Installing Go on a Windows system.........................................................................21 2.6 What is installed on your machine? ........................................................................26 2.7 The Go runtime ......................................................................................................27 2.8 A Go interpreter .....................................................................................................27
Page 7
Chapter 3—Editors, IDE’s and Other tools.........................................................................28 3.1 Basic requirements for a decent Go development environment ................................28 3.2 Editors and Integrated Development Environments ................................................29 3.2.1. Golang LiteIDE .........................................................................................32 3.2.2. GoClipse .....................................................................................................33 3.3 Debuggers ...............................................................................................................34 3.4 Building and running go-programs with command- and Makefiles .........................35 3.5 Formatting code: go fmt or gofmt ...........................................................................39 3.6 Documenting code: go doc or godoc .......................................................................40 3.7 Other tools ..............................................................................................................41 3.8 Go’s performance ....................................................................................................41 3.9 Interaction with other languages. .............................................................................43 3.9.1. Interacting with C ......................................................................................43 3.9.2. Interacting with C++ ...................................................................................45 PART 2—CORE CONSTRUCTS AND TECHNIQUES OF THE LANGUAGE Chapter 4—Basic constructs and elementary data types ......................................................49 4.1. Filenames—Keywords—Identifiers .........................................................................49 4.2. Basic structure and components of a Go-program ..................................................50 4.2.1 Packages, import and visibility .....................................................................51 4.2.3 Comments ...................................................................................................56 4.2.4 Types............................................................................................................57 4.2.5 General structure of a Go-program ..............................................................58 4.2.6 Conversions .................................................................................................60 4.2.7 About naming things in Go .........................................................................60 4.3. Constants ...............................................................................................................60 4.4. Variables .................................................................................................................63 4.4.1 Introduction ................................................................................................63 4.4.2 Value types and reference types ....................................................................66 4.4.3 Printing........................................................................................................68 4.4.4 Short form with the := assignment operator .................................................69 4.4.5 Init-functions ...............................................................................................70 4.5. Elementary types and operators ..............................................................................73 4.5.1. Boolean type bool .......................................................................................73 4.5.2. Numerical types ..........................................................................................75 4.5.2.1 ints and floats ............................................................................................75 4.5.2.2 Complex numbers ....................................................................................79 4.5.2.3 Bit operators .............................................................................................79 4.5.2.4 Logical operators .......................................................................................81
Page 8
4.5.2.5 Arithmetic operators ................................................................................82 4.5.2.6 Random numbers .....................................................................................82 4.5.3. Operators and precedence ...........................................................................84 4.5.4. Aliasing types ..............................................................................................84 4.5.5. Character type ............................................................................................85 4.6. Strings ....................................................................................................................86 4.7. The strings and strconv package .............................................................................88 4.7.1—Prefixes and suffixes: ..................................................................................88 4.7.2—Testing whether a string contains a substring: ............................................89 4.7.3—Indicating at which position (index) a substring or character occurs in a string: ..................................................................................................89 4.7.4—Replacing a substring: ...............................................................................90 4.7.5—Counting occurrences of a substring: .........................................................90 4.7.6—Repeating a string:.....................................................................................90 4.7.7—Changing the case of a string:....................................................................91 4.7.8—Trimming a string: ....................................................................................92 4.7.9—Splitting a string: .......................................................................................92 4.7.10—Joining over a slice: .................................................................................92 4.7.11—Reading from a string: .............................................................................93 4.8. Times and dates ......................................................................................................95 4.9. Pointers ..................................................................................................................96 Chapter 5—Control structures ..........................................................................................101 5.1—The if else construct ...........................................................................................101 5.2—Testing for errors on functions with multiple return values .................................106 5.3—The switch keyword ...........................................................................................110 5.4—The for construct ...............................................................................................114 5.4.1 Counter-controlled iteration ......................................................................114 Character on position 2 is: ..........................................................................................116 5.4.2 Condition-controlled iteration ..................................................................117 5.4.3 Infinite loops ............................................................................................118 5.4.4 The for range construct ..............................................................................119 5.5—Break / continue .................................................................................................121 5.6—Use of labels with break and continue—goto ......................................................123 Chapter 6—Functions.......................................................................................................126 6.1 Introduction ..........................................................................................................126 6.2 Parameters and return values .................................................................................129 6.2.1 Call by value / Call by reference .................................................................129 6.2.2 Named return variables ..............................................................................131
Page 9
6.2.3 Blank identifier ..........................................................................................133 6.2.4 Changing an outside variable .....................................................................134 6.3 Passing a variable number of parameters ................................................................135 6.4 Defer and tracing ..................................................................................................137 6.5 Built-in functions ..................................................................................................142 6.6 Recursive functions ...............................................................................................143 6.8 Closures (function literals) ....................................................................................147 6.9 Applying closures: a function returning another function .....................................150 6.10 Debugging with closures .....................................................................................153 6.11 Timing a function ..............................................................................................154 6.12 Using memoization for performance ...................................................................154 Chapter 7—Arrays and Slices ............................................................................................157 7.1 Declaration and initialization ................................................................................157 7.1.1 Concept .....................................................................................................157 7.1.2 Array literals ...............................................................................................161 7.1.3 Multidimensional arrays .............................................................................162 7.1.4 Passing an array to a function .....................................................................163 7.2 Slices .....................................................................................................................164 7.2.1 Concept .....................................................................................................164 7.2.2 Passing a slice to a function ........................................................................168 7.2.3 Creating a slice with make() .......................................................................168 7.2.4 Difference between new() and make() ........................................................170 7.2.5 Multidimensional slices ..............................................................................171 7.2.6 The bytes package ......................................................................................171 7.3 For range construct ...............................................................................................172 7.4 Reslicing ................................................................................................................175 7.5 Copying and appending slices ...............................................................................176 7.6 Applying strings, arrays and slices ..........................................................................178 7.6.1 Making a slice of bytes from a string ..........................................................178 7.6.2 Making a substring of a string ....................................................................179 7.6.3 Memory representation of a string and a slice .............................................179 7.6.4 Changing a character in a string .................................................................180 7.6.5 Comparison function for byte arrays ..........................................................180 7.6.6 Searching and sorting slices and arrays ......................................................181 7.6.7 Simulating operations with append ............................................................182 7.6.8 Slices and garbage collection ......................................................................182
Page 10
Chapter 8—Maps .............................................................................................................185 8.1 Declaration, initialization and make ......................................................................185 8.1.1 Concept .....................................................................................................185 8.1.2 Map capacity .............................................................................................188 8.1.3 Slices as map values ....................................................................................188 8.2 Testing if a key-value item exists in a map—Deleting an element ..........................188 8.3 The for range construct .........................................................................................190 8.4 A slice of maps .....................................................................................................191 8.5 Sorting a map ........................................................................................................192 8.6 Inverting a map .....................................................................................................194 Chapter 9—Packages ........................................................................................................196 A The standard library .................................................................................................196 9.1 Overview of the standard library. ...........................................................................196 9.2 The regexp package. ..............................................................................................199 9.3 Locking and the sync package. ..............................................................................200 9.4 Accurate computations and the big package. .........................................................202 B Custom and external packages: use, build, test, document, install ............................203 9.5 Custom packages and visibility ..............................................................................203 9.6 Using godoc for your custom packages. .................................................................208 9.7 Using go install for installing custom packages. .....................................................210 9.8 Custom packages: map structure, go install and go test .........................................212 9.8.1 Map-structure for custom packages ............................................................212 9.8.2 Locally installing the package .....................................................................215 9.8.3 OS dependent code ....................................................................................216 9.9 Using git for distribution and installation. .............................................................216 9.9.1 Installing to github ....................................................................................216 9.9.2 Installing from github ................................................................................217 9.10 Go external packages and projects. .....................................................................218 9.11 Using an external library in a Go program. ..........................................................219 Chapter 10—Structs and Methods ....................................................................................224 10.1 Definition of a struct ...........................................................................................224 10.2 Creating a struct variable with a Factory method .................................................232 10.2.1 A factory for structs..................................................................................232 10.2.2 new() and make() revisited for maps and structs: ......................................234 10.3 Custom package using structs ..............................................................................235 10.4 Structs with tags ..................................................................................................236 10.5 Anonymous fields and embedded structs .............................................................237 10.5.1 Definition ................................................................................................237
Page 11
10.5.2 Embedded structs ....................................................................................238 10.5.3 Conflicting names ....................................................................................239 10.6 Methods ..............................................................................................................240 10.6.1 What is a method? ...................................................................................240 10.6.2 Difference between a function and a method ...........................................244 10.6.3 Pointer or value as receiver .......................................................................245 10.6.4 Methods and not-exported fields .............................................................247 10.6.5 Methods on embedded types and inheritance ...........................................248 10.6.6 How to embed functionality in a type ......................................................251 10.6.7 Multiple inheritance .................................................................................253 10.6.8 Universal methods and method naming ...................................................256 10.6.9 Comparison between Go types and methods and other object-oriented languages. .........................................................................256 10.7 The String()-method and format specifiers for a type...........................................258 10.8 Garbage collection and SetFinalizer .....................................................................261 Chapter 11—Interfaces and reflection ...............................................................................263 11.1 What is an interface? ...........................................................................................263 11.2 Interface embedding interface(s) ..........................................................................270 11.3 How to detect and convert the type of an interface variable: type assertions ........270 11.4 The type switch ...................................................................................................273 11.5 Testing if a value implements an interface ............................................................274 11.6 Using method sets with interfaces ........................................................................275 11.7 1st example: sorting with the Sorter interface .......................................................277 11.8 2nd example: Reading and Writing .....................................................................282 11.9 Empty Interface...................................................................................................284 11.9.1 Concept ...................................................................................................284 11.9.2 Constructing an array of a general type or with variables of different types ...........................................................................................286 11.9.3 Copying a data-slice in a slice of interface{} ..............................................287 11.9.4 Node structures of general or different types ............................................288 11.9.5 Interface to interface ................................................................................289 11.10 The reflect package ............................................................................................290 11.10.1 Methods and types in reflect ..................................................................290 11.10.2 Modifying (setting) a value through reflection........................................293 11.10.3 Reflection on structs ..............................................................................294 11.11 Printf and reflection. .........................................................................................296 11.12 Interfaces and dynamic typing ...........................................................................298 11.12.1 Dynamic typing in Go ...........................................................................298 11.12.2 Dynamic method invocation ..................................................................300
Page 12
11.12.3 Extraction of an interface .......................................................................301 11.12.4 Explicitly indicating that a type implements an interface........................303 11.12.5 Empty interface and function overloading..............................................304 11.12.6 Inheritance of interfaces .........................................................................304 11.13 Summary: the object-orientedness of Go ...........................................................306 11.14 Structs, collections and higher order functions ..................................................306 PART 3—ADVANCED GO Chapter 12—Reading and writing ....................................................................................313 12.1 Reading input from the user ................................................................................313 12.2 Reading from and writing to a file .......................................................................317 12.2.1 Reading from a file ...................................................................................317 12.2.2 The package compress: reading from a zipped file ....................................321 12.2.3 Writing to a file ........................................................................................322 12.3 Copying files .......................................................................................................324 12.4 Reading arguments from the command-line ........................................................325 12.4.1 With the os-package .................................................................................325 12.4.2 With the flag-package ..............................................................................326 12.5 Reading files with a buffer ...................................................................................328 12.6 Reading and writing files with slices ....................................................................330 12.7 Using defer to close a file ....................................................................................332 12.8 A practical example of the use of interfaces: fmt.Fprintf .....................................332 12.9 The json dataformat ............................................................................................334 12.10 The xml dataformat ...........................................................................................340 12.11 Datatransport through gob ................................................................................342 12.12 Cryptography with go .......................................................................................345 Chapter 13—Error-handling and Testing ..........................................................................348 13.1 Error-handling ....................................................................................................349 13.1.1 Defining errors .........................................................................................349 13.1.2 Making an error-object with fmt .............................................................353 13.2 Run-time exceptions and panic ...........................................................................353 13.4 Error-handling and panicking in a custom package .............................................357 13.5 An error-handling scheme with closures ..............................................................360 13.6 Starting an external command or program ..........................................................363 13.7 Testing and benchmarking in Go ........................................................................364 13.8 Testing: a concrete example .................................................................................367 13.9 Using table-driven tests. ......................................................................................369 13.10 Investigating performance: tuning and profiling Go programs ...........................371
Page 13
13.10.1 Time and memory consumption ............................................................371 13.10.2 Tuning with go test ................................................................................371 13.10.3 Tuning with pprof ..................................................................................371 Chapter 14—Goroutines and Channels ............................................................................375 14.1 Concurrency, parallelism and goroutines .............................................................375 14.1.1 What are goroutines? ...............................................................................375 14.1.2 The difference between concurrency and parallelism ................................377 14.1.3 Using GOMAXPROCS ...........................................................................378 14.1.4 How to specify the number of cores to be used on the command-line?.....379 14.1.5 Goroutines and coroutines .......................................................................381 14.2 Channels for communication between goroutines ...............................................381 14.2.1 Concept ...................................................................................................381 14.2.2 Communication operator <- ....................................................................383 14.2.3 Blocking of channels ................................................................................385 14.2.4 Goroutines synchronize through the exchange of data on one (or more) channel(s). ......................................................................................387 14.2.5 Asynchronous channels—making a channel with a buffer ........................387 14.2.6 Goroutine using a channel for outputting result(s) ...................................388 14.2.7 Semaphore pattern ...................................................................................389 14.2.8 Implementing a parallel for-loop ..............................................................391 14.2.9 Implementing a semaphore using a buffered channel ...............................391 14.2.10 For—range applied to channels ..............................................................394 14.2.11 Channel directionality............................................................................396 14.3 Synchronization of goroutines: closing a channel—testing for blocked channels .400 14.4 Switching between goroutines with select ............................................................403 14.5 Channels, Timeouts and Tickers ..........................................................................408 14.6 Using recover with goroutines .............................................................................412 14.7 Comparing the old and the new model: Tasks and Worker processes. ..................413 14.8 Implementing a lazy generator .............................................................................416 14.9 Implementing Futures .........................................................................................420 14.10 Multiplexing .....................................................................................................421 14.10.1 A typical client-server pattern .................................................................421 14.10.2 Teardown: shutdown the server by signaling a channel ...........................424 14.11 Limiting the number of requests processed concurrently ...................................427 14.12 Chaining goroutines ..........................................................................................428 14.13 Parallelizing a computation over a number of cores ...........................................429 14.14 Parallelizing a computation over a large amount of data ....................................430 14.15 The leaky bucket algorithm ...............................................................................431
Page 14
14.16 Benchmarking goroutines. .................................................................................433 14.17 Concurrent acces to objects by using a channel. ................................................434 Chapter 15—Networking, templating and web-applications .............................................436 15.1 A tcp-server ........................................................................................................436 15.2 A simple webserver ..............................................................................................445 15.3 Polling websites and reading in a web page ..........................................................448 15.4 Writing a simple web application ........................................................................452 15.5 Making a web application robust .........................................................................454 15.6 Writing a web application with templates ............................................................456 15.7 Exploring the template package ...........................................................................461 15.7.1. Field substitution: {{.FieldName}} ...........................................................462 15.7.2. Validation of the templates ......................................................................463 15.7.3 If-else .......................................................................................................464 15.7.4 Dot and with-end ....................................................................................465 15.7.5 Template variables $ .................................................................................466 15.7.6 Range-end ................................................................................................467 15.7.7 Predefined template functions ..................................................................467 15.8 An elaborated webserver with different functions ................................................468 (works only on Unix because calls /bin/date) .......................................................474 15.9 Remote procedure calls with rpc ..........................................................................474 15.10 Channels over a network with netchan ..............................................................477 15.11 Communication with websocket .......................................................................478 15.12 Sending mails with smtp ...................................................................................480 PART 4—APPLYING GO Chapter 16—Common Go Pitfalls or Mistakes .................................................................485 16.1 Hiding (shadowing) a variable by misusing short declaration...............................486 16.2 Misusing strings. .................................................................................................486 16.3 Using defer for closing a file in the wrong scope. .................................................487 16.4 Confusing new() and make() ...............................................................................488 16.5 No need to pass a pointer to a slice to a function .................................................488 16.6 Using pointers to interface types ..........................................................................488 16.7 Misusing pointers with value types ......................................................................489 16.8 Misusing goroutines and channels .......................................................................489 16.9 Using closures with goroutines ............................................................................490 16.10 Bad error handling ............................................................................................491 16.10.1 Don’t use booleans: ................................................................................491 16.10.2 Don’t clutter your code with error-checking: ..........................................492
Page 15
Chapter 17—Go Language Patterns ..................................................................................494 17.1 The comma, ok pattern .......................................................................................494 17.2 The defer pattern .................................................................................................495 17.3 The visibility pattern ...........................................................................................497 17.4 The operator pattern and interface ......................................................................497 17.4.1 Implement the operators as functions.......................................................497 17.4.2 Implement the operators as methods ........................................................498 17.4.3 Using an interface ....................................................................................499 Chapter 18—Useful Code Snippets—Performance Advice ................................................500 18.1 Strings .................................................................................................................500 18.2 Arrays and slices ..................................................................................................501 18.3 Maps ...................................................................................................................502 18.4 Structs .................................................................................................................502 18.5 Interfaces .............................................................................................................503 18.6 Functions ............................................................................................................503 18.7 Files .....................................................................................................................504 18.8 Goroutines and channels .....................................................................................505 18.9 Networking and web applications ........................................................................507 18.9.1. Templating: .....................................................................................................507 18.10 General .............................................................................................................508 18.11 Performance best practices and advice ...............................................................508 Chapter 19—Building a complete application ...................................................................509 19.1 Introduction ........................................................................................................509 19.2 Introducing Project UrlShortener ........................................................................509 19.3 Data structure .....................................................................................................510 19.4 Our user interface: a web server frontend ............................................................515 19.5 Persistent storage: gob .........................................................................................519 19.6 Using goroutines for performance .......................................................................524 19.7 Using json for storage ..........................................................................................527 19.8 Multiprocessing on many machines .....................................................................528 19.9 Using a ProxyStore ..............................................................................................532 19.10 Summary and enhancements .............................................................................536 Chapter 20—Go in Google App Engine ...........................................................................538 20.1 What is Google App Engine ? ..............................................................................538 20.2 Go in the cloud ..................................................................................................540 20.3 Installation of the Go App Engine SDK: the development environment for Go ..540
Page 16
20.3.1. Installation ..............................................................................................540 20.3.2. Checking and testing ..............................................................................542 20.4 Building your own Hello world app ...................................................................543 20.4.1 Map structure—Creating a simple http-handler .......................................543 20.4.2 Creating the configuration file app.yaml ..................................................544 20.4.3 Iterative development ...............................................................................548 20.4.4. Integrating with the GoClipse IDE .........................................................548 20.5 Using the Users service and exploring its API ......................................................549 20.6 Handling forms ...................................................................................................551 20.7 Using the datastore ..............................................................................................552 20.8 Uploading to the cloud ......................................................................................556 Chapter 21—Real World Uses of Go ................................................................................559 21.1 Heroku—a highly available consistent data store in Go. .....................................559 21.2 MROffice—a VOIP system for call centers in Go. ..............................................561 21.3 Atlassian—a virtual machine cluster management system. ...................................562 21.4 Camlistore—a content addressable storage system. ..............................................563 21.5 Other usages of the Go language. ........................................................................563 APPENDICES ..................................................................................................................567 (A) CODE REFERENCE ..........................................................................................567 (B)CUTE GO QUOTES. ...........................................................................................571 GO QUOTES: TRUE BUT NOT SO CUTE. ..................................................572 (C) LIST OF CODE EXAMPLES (Listings) ..............................................................572 (E) References in the text to Go—packages .................................................................583 (F) References in the text to Go—tools .......................................................................586 (G) Answers to Questions ...........................................................................................586 (H) ANSWERS TO EXERCISES ...............................................................................590 (I) BIBLIOGRAPHY (Resources and References) .......................................................593 INDEX .............................................................................................................................597
Page 17
(This page has no text content)
Page 18
LIsT of ILLusTraTIons Chapter 1—Origins, Context and Popularity of Go ..............................................................1 Fig 1.1: The designers of Go: Griesemer, Thompson and Pike .........................................1 Fig 1.2: The logo’s of Go .................................................................................................3 Fig 1.3: Influences on Go ................................................................................................5 Chapter 3—Editors, IDE’s and Other tools.........................................................................28 Fig 3.1: LiteIDE and its AST-view .................................................................................33 Fig 3.2: GoClipse and its outline code-view ..................................................................34 Chapter 4—Basic constructs and elementary data types ......................................................49 Fig 4.1: Value type .........................................................................................................67 Fig 4.2: Assignment of value types .................................................................................67 Fig 4.3: Reference types and assignment ........................................................................67 Fig 4.4: Pointers and memory usage ..............................................................................98 Fig 4.5: Pointers and memory usage, 2 ..........................................................................99 Chapter 7—Arrays and Slices ............................................................................................157 Fig 7.1: Array in memory ............................................................................................158 Fig 7.2: Slice in memory .............................................................................................166 Chapter 9—Packages ........................................................................................................196 Fig 9.1: Package documentation with godoc ................................................................210 Chapter 10—Structs and Methods ....................................................................................224 Fig 10.1: Memory layout of a struct ............................................................................227 Fig 10.2: Memory layout of a struct of structs .............................................................229 Fig. 10.3: Linked list as recursive struct .......................................................................230 Fig 10.4: Binary tree as recursive struct ........................................................................230 Chapter 11—Interfaces and reflection ...............................................................................263 Fig 11.1: Interface value in memory ............................................................................264
Page 19
Chapter 14—Goroutines and Channels ............................................................................375 Fig 14.1: Channels and goroutines ..............................................................................382 Fig 14.2: The sieve prime-algorithm ............................................................................397 Chapter 15—Networking, templating and web-applications .............................................436 Fig 15.1—Screen of exercise 15.6 ................................................................................454 Chapter 19—Building a complete application ...................................................................509 Fig 19.1: Handler functions in goto ............................................................................515 Fig 19.2: The Add handler ..........................................................................................518 Fig 19.3: The response of the Add handler ..................................................................519 Fig 19.4: The response of the Redirect handler ............................................................519 Fig 19.5: Distributing the work load over master- and slave computers .......................529 Chapter 20—Go in Google App Engine ...........................................................................538 Fig 20.1: The Application Control Panel .....................................................................558
Page 20
xix Preface Code less, compile quicker, execute faster => have more fun! This text presents the most comprehensive treatment of the Go programming language you can find. It draws on the whole spectrum of Go sources available: online documentation and blogs, books, articles, audio and video, and my own experience in software engineering and teaching programming languages and databases, organizing the concepts and techniques in a systematic way. Several researchers and developers at Google experienced frustration with the software development processes within the company, particularly using C++ to write large server software. The binaries tended to be huge and took a long time to compile, and the language itself was quite old. A lot of the ideas and changes in hardware that have come about in the last couple of decades haven’t had a chance to influence C++. So the researchers sat down with a clean sheet of paper and tried to design a language that would solve the problems they had: 1. software needs to built quickly, 2. the language should run well on modern multi-core hardware, 3. the language should work well in a networked environment, 4. the language should be a pleasure to use. And so was born “Go”, a language that has the feel of a dynamic language like Python or Ruby, but has the performance and safety of languages like C or Java. Go seeks to reinvent programming in the most practical of ways: its not a fundamentally new language with strange syntax and arcane concepts; instead it builds and improves a lot on the existing C/Java/C#-style syntax. It proposes interfaces for object-oriented programming and goroutines / channels for concurrent and parallel programming. This book is intended for developers who want to learn this new, fascinating and promising language. Some basic knowledge of programming and some experience with a programming language and environment is assumed, but a thorough knowledge of C or Java or the like is not needed.
The above is a preview of the first 20 pages. Register to read the complete e-book.

Recommended for You

Loading recommended books...
Failed to load, please try again later

Tip the Site

Scan the WeChat Pay or Alipay code to tip. No login required.

WeChat Pay
Alipay
← Back to List