@Preamble{
"\input bibnames.sty " #
"\input path.sty " #
"\def \TM {${}^{\sc TM}$} " #
"\ifx \undefined \booktitle \def \booktitle #1{{{\em #1}}} \fi" #
"\ifx \undefined \pkg \def \pkg #1{{{\tt #1}}} \fi" #
"\hyphenation{ }"
}
@String{ack-nhfb = "Nelson H. F. Beebe,
University of Utah,
Department of Mathematics, 110 LCB,
155 S 1400 E RM 233,
Salt Lake City, UT 84112-0090, USA,
Tel: +1 801 581 5254,
FAX: +1 801 581 4148,
e-mail: \path|beebe@math.utah.edu|,
\path|beebe@acm.org|,
\path|beebe@computer.org| (Internet),
URL: \path|https://www.math.utah.edu/~beebe/|"}
@String{inst-UTAH-MATH = "University of Utah, Department of Mathematics"}
@String{inst-UTAH-MATH:adr = "Salt Lake City, UT 84112-0090, USA"}
@String{j-CACM = "Communications of the ACM"}
@String{j-IEEE-SOFTWARE = "IEEE Software"}
@String{j-IEEE-TRANS-NETWORKING = "IEEE\slash ACM Transactions on Networking"}
@String{j-IEEE-TRANS-SOFTW-ENG = "IEEE Transactions on Software Engineering"}
@String{j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER = "International Journal on
Software Tools for Technology Transfer (STTT)"}
@String{j-J-OPEN-SOURCE-SOFT = "Journal of Open Source Software"}
@String{j-J-SYST-SOFTW = "The Journal of Systems and Software"}
@String{j-OPER-SYS-REV = "Operating Systems Review"}
@String{j-PACMPL = "Proceedings of the ACM on Programming
Languages (PACMPL)"}
@String{j-SIGADA-LETTERS = "ACM SIGADA Ada Letters"}
@String{j-SOFTWAREX = "SoftwareX"}
@String{j-SPE = "Soft\-ware\emdash Prac\-tice and Experience"}
@String{pub-APRESS = "Apress"}
@String{pub-APRESS:adr = "Berkeley, CA, USA"}
@String{pub-AW = "Ad{\-d}i{\-s}on-Wes{\-l}ey"}
@String{pub-AW:adr = "Reading, MA, USA"}
@String{pub-IEEE = "IEEE Computer Society Press"}
@String{pub-IEEE:adr = "1109 Spring Street, Suite 300,
Silver Spring, MD 20910, USA"}
@String{pub-MANNING = "Manning Publications"}
@String{pub-MANNING:adr = "Greenwich, CT, USA"}
@String{pub-NO-STARCH = "No Starch Press"}
@String{pub-NO-STARCH:adr = "San Francisco, CA, USA"}
@String{pub-ORA-MEDIA = "O'Reilly Media, Inc."}
@String{pub-ORA-MEDIA:adr = "1005 Gravenstein Highway North,
Sebastopol, CA 95472, USA"}
@String{pub-PACKT = "Packt Publishing"}
@String{pub-PACKT:adr = "Birmingham, UK"}
@String{pub-SV = "Spring{\-}er-Ver{\-}lag"}
@String{pub-SV:adr = "Berlin, Germany~/ Heidelberg,
Germany~/ London, UK~/ etc."}
@Book{Anonymous:2012:GPL,
author = "Anonymous",
title = "The {Go} Programming Language Phrasebook",
publisher = "Addison-Wesley Professional",
address = "????",
pages = "????",
year = "2012",
ISBN = "0-13-291896-X",
ISBN-13 = "978-0-13-291896-1",
bibdate = "Thu Apr 22 07:17:47 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
}
@Article{Meyerson:2014:GPL,
author = "Jeff Meyerson",
title = "The {Go} Programming Language",
journal = j-IEEE-SOFTWARE,
volume = "31",
number = "5",
pages = "104--104",
month = sep # "\slash " # oct,
year = "2014",
CODEN = "IESOEG",
DOI = "https://doi.org/10.1109/MS.2014.127",
ISSN = "0740-7459 (print), 1937-4194 (electronic)",
ISSN-L = "0740-7459",
bibdate = "Thu Feb 12 15:59:37 MST 2015",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib",
URL = "http://csdl.computer.org/csdl/mags/so/2014/05/mso2014050104.html",
abstract-URL = "http://csdl.computer.org/csdl/mags/so/2014/05/mso2014050104-abs.html",
acknowledgement = ack-nhfb,
fjournal = "IEEE Software",
journal-URL = "https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=52",
journalabr = "IEEE Software",
}
@Book{Varghese:2015:WDG,
author = "Shiju Varghese",
title = "{Web} Development with {Go}: Building Scalable {Web}
Apps and {RESTful} Services",
publisher = pub-APRESS,
address = pub-APRESS:adr,
pages = "xx + 289 + 69",
year = "2015",
ISBN = "1-4842-1052-2",
ISBN-13 = "978-1-4842-1052-9",
LCCN = "????",
bibdate = "Thu Apr 22 10:58:58 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Take a deep dive into web development using the Go
programming language to build web apps and RESTful
services to create reliable and efficient software. Web
Development with Go provides Go language fundamentals
and then moves on to advanced web development concepts
and successful deployment of Go web apps to the cloud.
Web Development with Go will teach you how to develop
scalable real-world web apps, RESTful services, and
backend systems with Go. The book starts off by
covering Go programming language fundamentals as a
prerequisite for web development. After a thorough
understanding of the basics, the book delves into web
development using the built-in package, net/http. With
each chapter you'll be introduced to new concepts for
gradually building a real-world web system. The book
further shows you how to integrate Go with other
technologies. For example, it provides an overview of
using MongoDB as a means of persistent storage, and
provides an end-to-end REST API sample as well.",
acknowledgement = ack-nhfb,
subject = "Computer science; Programming languages (Electronic
computers); Programming Languages, Compilers,
Interpreters; Computer science; Programming languages
(Electronic computers)",
tableofcontents = "1: Getting Started With Go \\
2: Go Fundamentals \\
3: User Defined Types and Concurrency \\
4: Getting Started with Web Development \\
5: Go Templates \\
6: HTTP Middleware \\
7: Authentication for Web Apps \\
8: Persistence with MongoDB \\
9: Building RESTful Services \\
10: Testing Go Applications \\
11: Building Go Web Applications on Google Cloud",
}
@Book{Butcher:2016:GP,
author = "Matt Butcher and Matt Farina",
title = "Go in practice",
publisher = pub-MANNING,
address = pub-MANNING:adr,
pages = "xxi + 287",
year = "2016",
ISBN = "1-63343-007-3",
ISBN-13 = "978-1-63343-007-5",
LCCN = "QA76.73.G63 B87 2016",
bibdate = "Thu Apr 22 10:30:10 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://proquest.tech.safaribooksonline.de/9781633430075",
abstract = "Go in Practice guides you through 70 real-world
techniques in key areas like package management,
microservice communication, and more. Following a
cookbook-style Problem/Solution/Discussion format, this
practical handbook builds on the foundational concepts
of the Go language and introduces specific strategies
you can use in your day-to-day applications. About the
Technology Go may be the perfect systems language.
Built with simplicity, concurrency, and modern
applications in mind, Go provides the core tool set for
rapidly building web, cloud, and systems applications.
If you know a language like Java or C\#, it's easy to
get started with Go; the trick is finding the practical
dirt-under-the-fingernails techniques that you need to
build production-ready code. About the Book Go in
Practice guides you through dozens of real-world
techniques in key areas. Following a cookbook-style
Problem/Solution/Discussion format, this practical
handbook builds on the foundational concepts of the Go
language and introduces specific strategies you can use
in your day-to-day applications. You'll learn
techniques for building web services, using Go in the
cloud, testing and debugging, routing, network
applications, and much more. After finishing this book,
you will be ready to build sophisticated cloud-native
Go applications. What's Inside Dozens of specific,
practical Golang techniques Using Go for devops and
cloudops Writing RESTful web services and microservices
Practical web dev techniques About the Reader Written
for experienced developers who have already started
exploring Go and want to use it effectively in a
production setting. About the Authors Matt Butcher is a
software architect at Deis. Matt Farina is a Principal
Engineer in the Advanced Technology Group at Hewlett
Packard Enterprise. They are both authors, speakers,
and regular open source contributors.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Go (Computer program
language); Go (Computer program language)",
tableofcontents = "Part 1. Background and fundamentals. Getting into
Go \\
A solid foundation \\
Concurrency in Go \\
Part 2. Well-rounded applications. Handling errors and
panic \\
Debugging and testing \\
Part 3. An interface for your applications. HTML and
email template patterns \\
Serving and receiving assets and forms \\
Working with web services \\
Part 4. Taking your applications to the cloud. Using
the cloud \\
Communication between cloud services \\
Reflection and code generation",
}
@Book{Chang:2016:GWP,
author = "Sau Sheong Chang",
title = "{Go} {Web} programming",
publisher = pub-MANNING,
address = pub-MANNING:adr,
pages = "xx + 292",
year = "2016",
ISBN = "1-61729-256-7",
ISBN-13 = "978-1-61729-256-9",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 10:28:32 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://proquest.tech.safaribooksonline.de/9781617292569",
abstract = "Go Web Programming teaches you how to build scalable,
high-performance web applications in Go using modern
design principles. About the Technology The Go language
handles the demands of scalable, high-performance web
applications by providing clean and fast compiled code,
garbage collection, a simple concurrency model, and a
fantastic standard library. It's perfect for writing
microservices or building scalable, maintainable
systems. About the Book Go Web Programming teaches you
how to build web applications in Go using modern design
principles. You'll learn how to implement the
dependency injection design pattern for writing test
doubles, use concurrency in web applications, and
create and consume JSON and XML in web services. Along
the way, you'll discover how to minimize your
dependence on external frameworks, and you'll pick up
valuable productivity techniques for testing and
deploying your applications. What's Inside Basics
Testing and benchmarking Using concurrency Deploying to
standalone servers, PaaS, and Docker Dozens of tips,
tricks, and techniques About the Reader This book
assumes you're familiar with Go language basics and the
general concepts of web development. About the Author
Sau Sheong Chang is Managing Director of Digital
Technology at Singapore Power and an active contributor
to the Ruby and Go communities.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Web applications; Go
(Computer program language); Development; Programming;
Go (Computer program language); Web applications.",
}
@Book{Donovan:2016:GPL,
author = "Alan A. A. Donovan and Brian W. Kernighan",
title = "The {Go} Programming Language",
publisher = pub-AW,
address = pub-AW:adr,
pages = "xvii + 380",
year = "2016",
ISBN = "0-13-419044-0 (paperback)",
ISBN-13 = "978-0-13-419044-0 (paperback)",
LCCN = "QA76.73.G63 D66 2016",
bibdate = "Fri Oct 11 12:07:52 MDT 2019",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/master.bib;
https://www.math.utah.edu/pub/tex/bib/unix.bib;
z3950.loc.gov:7090/Voyager",
series = "Addison-Wesley professional computing series",
URL = "https://www.pearson.com/us/higher-education/program/Donovan-Go-Programming-Language-The/PGM234922.html",
abstract = "Go may be our generation's most important new
programming language. It is exceptionally expressive,
highly efficient in both compilation and execution, and
enables the development of extremely reliable and
robust programs. It shares the same spirit programmers
once found in C: it helps serious professional
programmers achieve maximum effect with minimum means.
Now, Go shares something else with C, too. Brian
Kernighan, who wrote the world's most respected and
useful C primer for working programmers, has just done
the same for Go. Together with Google Go insider Alan
Donovan, Kernighan explains what Go does and doesn't
borrow from C; the great ideas it borrows from other
modern languages; and how it avoids features that lead
to unnecessary complexity and unreliable code.
Throughout, their short, carefully-crafted code
examples demonstrate today's most effective Go idioms,
so you can start using Go effectively right from the
beginning, and quickly take advantage of its full
power. All code has been extensively reviewed by Go's
creators at Google for both completeness and
accuracy.",
acknowledgement = ack-nhfb,
author-dates = "1976--",
shorttableofcontents = "1: Tutorial \\
2: Program structure \\
3: Basic data types \\
4: Composite types \\
5: Functions \\
6: Methods \\
7: Interfaces \\
8: Goroutines and channels \\
9: Concurrency with shared variables \\
10: Packages and the Go tool \\
11: Testing \\
12: Reflection \\
13: Low-level programming",
subject = "Go (Computer program language); Open source software;
Programming; G (Lenguaje de programaci\'on para
computadora); Programaci\'on de computadoras",
tableofcontents = "Preface / xi \\
1: Tutorial / 1 \\
1.1 Hello, World / 1 \\
1.2 Command-Line Arguments / 4 \\
1.3 Finding Duplicate Lines / 8 \\
1.4 Animated GIFs / 13 \\
1.5 Fetching a URL / 15 \\
1.6 Fetching URLs Concurrently / 17 \\
1.7 A Web Server / 19 \\
1.8 Loose Ends / 23 \\
2: Program Structure / 27 \\
2.1 Names / 27 \\
2.2 Declarations / 28 \\
2.3 Variables / 30 \\
2.4 Assignments / 36 \\
2.5 Type Declarations / 39 \\
2.6 Packages and Files / 41 \\
2.7 Scope / 45 \\
3: Basic Data Types / 51 \\
3.1 Integers / 51 \\
3.2 Floating-Point Numbers / 56 \\
3.3 Complex Numbers / 61 \\
3.4 Booleans / 63 \\
3.5 Strings / 64 \\
3.6 Constants / 75 \\
4: Composite Types / 81 \\
4.1 Arrays / 81 \\
4.2 Slices / 84 \\
4.3 Maps / 93 \\
4.4 Structs / 99 \\
4.5 JSON / 107 \\
4.6 Text and HTML Templates / 113 \\
5: Functions / 119 \\
5.1 Function Declarations / 119 \\
5.2 Recursion / 121 \\
5.3 Multiple Return Values / 124 \\
5.4 Errors / 127 \\
5.5 Function Values / 132 \\
5.6 Anonymous Functions / 135 \\
5.7 Variadic Functions / 142 \\
5.8 Deferred Function Calls / 143 \\
5.9 Panic / 148 \\
5.10 Recover / 151 \\
6:. Methods / 155 \\
6.1 Method Declarations / 155 \\
6.2 Methods with a Pointer Receiver / 158 \\
6.3 Composing Types by Struct Embedding / 161 \\
6.4 Method Values and Expressions / 164 \\
6.5 Example: Bit Vector Type / 165 \\
6.6 Encapsulation / 168 \\
7: Interfaces / 171 \\
7.1 Interfaces as Contracts / 171 \\
7.2 Interface Types / 174 \\
7.3 Interface Satisfaction / 175 \\
7.4 Parsing Flags with flag.Value / 179 \\
7.5 Interface Values / 181 \\
7.6 Sorting with sort.Interface / 186 \\
7.7 The http.Handler Interface / 191 \\
7.8 The error Interface / 196 \\
7.9 Example: Expression Evaluator / 197 \\
7.10 Type Assertions / 205 \\
7.11 Discriminating Errors with Type Assertions / 206
\\
7.12 Querying Behaviors with Interface Type Assertions
/ 208 \\
7.13 Type Switches / 210 \\
7.14 Example: Token-Based XML Decoding / 213 \\
7.15 A Few Words of Advice / 216 \\
8: Goroutines and Channels / 217 \\
8.1 Goroutines / 217 \\
8.2 Example: Concurrent Clock Server / 219 \\
8.3 Example: Concu rent Echo Server / 222 \\
8.4 Channels / 225 \\
8.5 Looping in Parallel / 234 \\
8.6 Example: Concurrent Web Crawler / 239 \\
8.7 Multiplexing with select / 244 \\
8.8 Example: Concurrent Directory Traversal / 247 \\
8.9 Cancellation / 251 \\
8.10 Example: Chat Server / 253 \\
9: Concurrency with Shared Variables / 257 \\
9.1 Race Conditions / 257 \\
9.2 Mutual Exclusion: sync.Mutex / 262 \\
9.3 Read/Write Mutexes: sync.RWMutex / 266 \\
9.4 Memory Synchronization / 267 \\
9.5 Lazy Initialization: sync.Once / 268 \\
9.6 The Race Detector / 271 \\
9.7 Example: Concurrent Non-Blocking Cache / 272 \\
9.8 Goroutines and Threads / 280 \\
10: Packages and the Go Tool / 283 \\
10.1 Introduction / 283 \\
10.2 Import Paths / 284 \\
10.3 The Package Declaration / 285 \\
10.4 Import Declarations / 285 \\
10.5 Blank Imports / 286 \\
10.6 Packages and Naming / 289 \\
10.7 The Go Tool / 290 \\
11: Testing / 301 \\
11.1 The go test Tool / 302 \\
11.2 Test Functions / 302 \\
11.3 Coverage / 318 \\
11.4 Benchmark Functions / 321 \\
11.5 Profiling / 323 \\
11.6 Example Functions / 326 \\
12: Reflection / 329 \\
12.1 Why Reflection? / 329 \\
12.2 reflect.Type and reflect.Value / 330 \\
12.3 Display, a Recursive Value Printer / 333 \\
12.4 Example: Encoding S-Expressions / 338 \\
12.5 Setting Variables with reflect.Value / 341 \\
12.6 Example: Decoding S-Expressions / 344 \\
12.7 Accessing Struct Field Tags / 348 \\
12.8 Displaying the Methods of a Type / 351 \\
12.9 A Word of Caution / 352 \\
13: Low-Level Programming / 353 \\
13.1 unsafe.Sizeof, Alignof, and Offsetof / 354 \\
13.2 unsafe.Pointer / 356 \\
13.3 Example: Deep Equivalence / 358 \\
13.4 Calling C Code with cgo / 361 \\
13.5 Another Word of Caution / 366 \\
Index / 367",
}
@Book{Doxsey:2016:IGB,
author = "Caleb Doxsey",
title = "Introducing {Go}: Build Reliable, Scalable Programs",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "x + 111",
year = "2016",
ISBN = "1-4783-5582-4, 1-4919-4195-2 (paperback)",
ISBN-13 = "978-1-4783-5582-3, 978-1-4919-4195-9 (paperback)",
LCCN = "QA76.73.G63 D69 2016",
bibdate = "Thu Apr 22 10:07:34 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://proquest.tech.safaribooksonline.de/9781491941997",
abstract = "Perfect for beginners familiar with programming
basics, this hands-on guide provides an easy
introduction to Go, the general-purpose programming
language from Google. Author Caleb Doxsey covers the
language's core features with step-by-step instructions
and exercises in each chapter to help you practice what
you learn.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Go (Computer program
language); Go (Computer program language)",
tableofcontents = "Introduction \\
1. Getting started \\
2. Types \\
3. Variables \\
4. Control structures \\
5. Arrays, slices, and maps \\
6. Functions \\
7. Structs and interfaces \\
8. Packages \\
9. Testing \\
10. Concurrency \\
11. Next steps \\
A. Answers",
}
@InProceedings{Irawan:2016:TCG,
author = "Edbert Wijaya Irawan and Bayu Hendradjaya and Wikan
Danar Sunindyo",
editor = "{IEEE}",
booktitle = "{2016 International Conference on Data and Software
Engineering (ICoDSE)}",
title = "Test case generation method for {Go} language",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "1--5",
year = "2016",
DOI = "https://doi.org/10.1109/ICODSE.2016.7936140",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
}
@Book{Kennedy:2016:GA,
author = "William Kennedy",
title = "{Go} in action",
publisher = pub-MANNING,
address = pub-MANNING:adr,
pages = "xix + 241",
year = "2016",
ISBN = "1-61729-178-1",
ISBN-13 = "978-1-61729-178-4 pocket",
LCCN = "????",
bibdate = "Thu Apr 22 07:29:42 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Go in Action introduces the Go language, guiding you
from inquisitive developer to Go guru. The book begins
by introducing the unique features and concepts of Go.
Then, you'll get hands-on experience writing real-world
applications including websites and network servers, as
well as techniques to manipulate and convert data at
speeds that will make your friends jealous. -- Provided
by publisher.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Open source software",
tableofcontents = "Introducing Go \\
Go quick-start \\
Packaging and tooling \\
Arrays, slices, and maps \\
Go's type system \\
Concurrency \\
Concurrency patterns \\
Standard library \\
Testing and benchmarking",
}
@Book{Kozyra:2016:GBW,
author = "Nathan Kozyra",
title = "{Go}: Building {Web} Applications (1)",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "665",
year = "2016",
ISBN = "1-78712-349-9, 1-78712-659-5 (e-book)",
ISBN-13 = "978-1-78712-659-6",
LCCN = "TK5105.8885.L674",
bibdate = "Thu Apr 22 10:54:49 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://www.myilibrary.com?id=952170",
acknowledgement = ack-nhfb,
}
@Book{Ryer:2016:GPB,
author = "Mat Ryer",
title = "{Go} programming blueprints: build real-world,
production-ready solutions in {Go} using cutting-edge
technology and techniques",
publisher = pub-PACKT,
address = pub-PACKT:adr,
edition = "Second",
pages = "viii + 376",
year = "2016",
ISBN = "1-78646-247-8, 1-78646-894-8",
ISBN-13 = "978-1-78646-247-3, 978-1-78646-894-9",
LCCN = "????",
bibdate = "Thu Apr 22 10:47:38 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Build real-world, production-ready solutions in Go
using cutting-edge technology and techniques. About
This Book Get up to date with Go and write code capable
of delivering massive world-class scale performance and
availability Learn to apply the nuances of the Go
language, and get to know the open source community
that surrounds it to implement a wide range of start-up
quality projects Write interesting and clever but
simple code, and learn skills and techniques that are
directly transferrable to your own projects. Who This
Book Is For. If you are familiar with Go and are want
to put your knowledge to work, then this is the book
for you. Go programming knowledge is a must. What You
Will Learn Build quirky and fun projects from scratch
while exploring patterns, practices, and techniques, as
well as a range of different technologies Create
websites and data services capable of massive scale
using Go's net/http package, exploring RESTful patterns
as well as low-latency WebSocket APIs Interact with a
variety of remote web services to consume capabilities
ranging from authentication and authorization to a
fully functioning thesaurus Develop high-quality
command-line tools that utilize the powerful shell
capabilities and perform well using Go's in-built
concurrency mechanisms Build microservices for larger
organizations using the Go Kit library Implement a
modern document database as well as high-throughput
messaging queue technology to put together an
architecture that is truly ready to scale Write
concurrent programs and gracefully manage the execution
of them and communication by smartly using channels Get
a feel for app deployment using Docker and Google App
Engine. In Detail. Go is the language of the Internet
age, and the latest version of Go comes with major
architectural changes. Implementation of the language,
runtime, and libraries has changed significantly. The
compiler and runtime are now written entirely in Go.
The garbage collector is now concurrent and provides
dramatically lower pause times by running in parallel
with other Go routines when possible.This book will
show you how to leverage all the latest features and
much more. This book shows you how to build powerful
systems and drops you into real-world situations. You
will learn to develop high-quality command-line tools
that utilize the powerful shell capabilities and
perform well using Go's in-built concurrency
mechanisms. Scale, performance, and high availability
lie at the heart of our projects, and the lessons
learned throughout this book 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.Style and approach. This book
provides fun projects that involve building
applications from scratch. These projects will teach
you to build chat applications, a distributed system,
and a recommendation system.",
acknowledgement = ack-nhfb,
tableofcontents = "Preface \\
1: Chat Application with Web Sockets \\
A simple web server \\
Separating views from logic using templates \\
Doing things once \\
Using your own handlers \\
Properly building and executing Go programs \\
Modeling a chat room and clients on the server \\
Modeling the client \\
Modeling a room \\
Concurrency programming using idiomatic Go \\
Turning a room into an HTTP handler \\
Using helper functions to remove complexity \\
Creating and using rooms \\
Building an HTML and JavaScript chat client \\
Getting more out of templates \\
Tracing code to get a look under the hood \\
Writing a package using TDD \\
Interfaces \\
Unit tests \\
Red-green testing \\
Implementing the interface \\
Unexported types being returned to users \\
Using our new trace package \\
Making tracing optional \\
Clean package APIs \\
Summary \\
2: Adding User Accounts \\
Handlers all the way down \\
Making a pretty social sign-in page \\
Endpoints with dynamic paths \\
Getting started with OAuth2 \\
Open source OAuth2 packages \\
Tell the authorization providers about your app \\
Implementing external logging in \\
Logging in \\
Handling the response from the provider \\
Presenting the user data \\
Augmenting messages with additional data \\
Summary \\
3: Three Ways to Implement Profile Pictures \\
Avatars from the OAuth2 server \\
Getting the avatar URL \\
Transmitting the avatar URL \\
Adding the avatar to the user interface \\
Logging out \\
Making things prettier \\
Implementing Gravatar \\
Abstracting the avatar URL process \\
The auth service and the avatar's implementation \\
Using an implementation \\
The Gravatar implementation \\
Uploading an avatar picture \\
User identification \\
An upload form \\
Handling the upload \\
Serving the images \\
The Avatar implementation for local files \\
Supporting different file types \\
Refactoring and optimizing our code \\
Replacing concrete types with interfaces \\
Changing interfaces in a test-driven way \\
Fixing the existing implementations \\
Global variables versus fields \\
Implementing our new design \\
Tidying up and testing \\
Combining all three implementations \\
Summary \\
4: Command-Line Tools to Find Domain Names \\
Pipe design for command-line tools \\
Five simple programs \\
Sprinkle \\
Domainify \\
Coolify \\
Synonyms \\
Using environment variables for configuration \\
Consuming a web API \\
Getting domain suggestions \\
Composing all five programs \\
One program to rule them all \\
Summary \\
5: Building Distributed Systems and Working with
Flexible Data \\
The system design \\
The database design \\
Installing the environment \\
Introducing NSQ \\
NSQ driver for Go \\
Introducing MongoDB \\
MongoDB driver for Go \\
Starting the environment \\
Reading votes from Twitter \\
Authorization with Twitter \\
Extracting the connection \\
Reading environment variables \\
Reading from MongoDB \\
Reading from Twitter \\
Signal channels \\
Publishing to NSQ \\
Gracefully starting and stopping programs \\
Testing",
}
@Book{Vivien:2016:LGPh,
author = "Vladimir Vivien",
title = "Learning {Go} programming: an insightful guide to
learning the {Go} programming language",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "ix + 327",
year = "2016",
ISBN = "1-78439-233-2, 1-78439-543-9",
ISBN-13 = "978-1-78439-233-8, 978-1-78439-543-8",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 10:56:46 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://proquest.tech.safaribooksonline.de/9781784395438",
abstract = "An insightful guide to learning the Go programming
language. About This Book: Insightful coverage of Go
programming syntax, constructs, and idioms to help you
understand Go code effectively. Push your Go skills,
with topics such as, data types, channels, concurrency,
object-oriented Go, testing, and network programming.
Each chapter provides working code samples that are
designed to help reader quickly understand respective
topic. Who This Book Is For: If you have prior exposure
to programming and are interested in learning the Go
programming language, this book is designed for you. It
will quickly run you through the basics of programming
to let you exploit a number of features offered by Go
programming language. What You Will Learn: Install and
configure the Go development environment to quickly get
started with your first program. Use the basic elements
of the language including source code structure,
variables, constants, and control flow primitives to
quickly get started with Go Gain practical insight into
the use of Go's type system including basic and
composite types such as maps, slices, and structs. Use
interface types and techniques such as embedding to
create idiomatic object-oriented programs in Go.
Develop effective functions that are encapsulated in
well-organized package structures with support for
error handling and panic recovery. Implement goroutine,
channels, and other concurrency primitives to write
highly-concurrent and safe Go code. Write tested and
benchmarked code using Go's built test tools. Access OS
resources by calling C libraries and interact with
program environment at runtime. In Detail: 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 let programmers write correct and
predictable code using concurrency idioms and a
full-featured standard library. This is a step-by-step,
practical guide full of real world examples to help you
get started with Go in no time at all. We start off by
understanding the fundamentals of Go, followed by a
detailed description of the Go data types, program
structures and Maps. After this, you learn how to use
Go concurrency idioms to avoid pitfalls and create
programs that are exact in expected behavior. Next, you
will be familiarized with the tools and libraries that
are available in Go for writing and exercising tests,
benchmarking, and code coverage. Finally, 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. All the concepts are
explained in a crisp and concise manner and by the end
of this book, you will be able to create highly
efficient programs that you can deploy over cloud.
Style and approach: The book is written to serve as a
reader-friendly step-by-step guide to learning the Go
programming language. Each topic is sequentially
introduced to build on previous materials covered.
Every concept is introduced with easy-to-follow code
examples that focus on maximizing the understanding of
the topic at hand.",
acknowledgement = ack-nhfb,
subject = "Computer programming; Go (Computer program language)",
tableofcontents = "A first step in Go \\
Go language essentials \\
Go control flow \\
Data types \\
Functions in Go \\
Go packages and programs \\
Composite types \\
Methods, interfaces, objects \\
Concurrency \\
Data IO in Go \\
Writing networked services \\
Code testing",
}
@Book{Andrawos:2017:CNP,
author = "Mina Andrawos and Martin Helmich",
title = "Cloud native programming with {Golang}: develop
microservice-based high performance web apps for the
cloud with {Go}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "vi + 385",
year = "2017",
ISBN = "1-78712-598-X (print), 1-78712-796-6 (e-book)",
ISBN-13 = "978-1-78712-598-8 (print), 978-1-78712-796-8
(e-book)",
LCCN = "QA76.76.D47; QA76.73.G63 .A537 2017",
bibdate = "Thu Apr 22 09:54:38 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://proquestcombo.safaribooksonline.com/9781787125988",
abstract = "Discover practical techniques to build cloud-native
apps that are scalable, reliable, and always available.
About This Book Build well-designed and secure
microservices. Enrich your microservices with
continuous integration and monitoring. Containerize
your application with Docker Deploy your application to
AWS. Learn how to utilize the powerful AWS services
from within your application Who This Book Is For This
book is for developers who want to begin building
secure, resilient, robust, and scalable Go applications
that are cloud native. Some knowledge of the Go
programming language should be sufficient. To build the
front-end application, you will also need some
knowledge of JavaScript programming. What You Will
Learn Understand modern software applications
architectures Build secure microservices that can
effectively communicate with other services Get to know
about event-driven architectures by diving into message
queues such as Kafka, Rabbitmq, and AWS SQS. Understand
key modern database technologies such as MongoDB, and
Amazon's DynamoDB Leverage the power of containers
Explore Amazon cloud services fundamentals Know how to
utilize the power of the Go language to access key
services in the Amazon cloud such as S3, SQS, DynamoDB
and more. Build front-end applications using ReactJS
with Go Implement CD for modern applications In Detail
Awarded as one of the best books of all time by
BookAuthority, Cloud Native Programming with Golang
will take you on a journey into the world of
microservices and cloud computing with the help of Go.
Cloud computing and microservices are two very
important concepts in modern software architecture.
They represent key skills that ambitious software
engineers need to acquire in order to design and build
software applications capable of performing and
scaling. Go is a modern cross-platform programming
language that is very powerful yet simple; it is an
excellent choice for microservices and cloud
applications. Go is gaining more and more popularity,
and becoming a very attractive skill. This book starts
by covering the software architectural patterns of
cloud applications, as well as practical concepts
regarding how to scale, distribute, and deploy those
applications. You will also learn how to build a
JavaScript-based front-end for your application, using
TypeScript and React. From there, we dive into
commercial cloud offerings by covering AWS. Finally, we
conclude our book by providing some overviews of other
\ldots{}",
acknowledgement = ack-nhfb,
subject = "Application software; Development; Cloud computing;
Development; Cloud computing.",
tableofcontents = "Preface \\
1: Modern Microservice Architectures \\
Why Go? \\
Basic design goals \\
Cloud service models \\
Cloud application architecture patterns \\
The twelve-factor app \\
What are microservices? \\
Deploying microservices \\
REST web services and asynchronous messaging \\
The MyEvents platform \\
Summary \\
2: Building Microservices Using Rest APIs \\
The background \\
So, what are microservices? \\
Microservices internals \\
RESTful Web APIs \\
Gorilla web toolkit \\
Implementing a Restful API \\
Persistence layer \\
MongoDB \\
MongoDB and the Go language \\
Implementing our RESTful APIs handler functions \\
Summary \\
3: Securing Microservices \\
HTTPS \\
Symmetric cryptography \\
Symmetric-key algorithms in HTTPS \\
Asymmetric cryptography \\
Asymmetrical cryptography in HTTPS \\
Secure web services in Go \\
Obtaining a certificate \\
OpenSSL \\
generate\_cert.go \\
Building an HTTPS server in Go \\
Summary \\
4: Asynchronous Microservice Architectures Using
Message Queues \\
The publish/subscribe pattern \\
Introducing the booking service \\
Event collaboration \\
Implementing publish/subscribe with RabbitMQ \\
The Advanced Message Queueing Protocol \\
RabbitMQ quickstart with Docker \\
Advanced RabbitMQ setups \\
Connecting RabbitMQ with Go \\
Publishing and subscribing to AMQP messages \\
Building an event emitter \\
Building an event subscriber \\
Building the booking service \\
Event sourcing \\
Implementing publish/subscribe and event sourcing with
Apache Kafka \\
Kafka quickstart with Docker \\
Basic principles of Apache Kafka \\
Connecting to Kafka with Go \\
Publishing messages with Kafka \\
Consuming messages from Kafka \\
Summary \\
5: Building a Frontend with React \\
Getting started with React \\
Setting up Node.js and TypeScript \\
Initializing the React project \\
Basic React principles \\
Kick-starting the MyEvents frontend \\
Implementing the event list \\
Bringing your own client \\
Building the event list components \\
Enabling CORS in the backend services \\
Testing the event list \\
Adding routing and navigation \\
Implementing the booking process \\
Summary \\
6: Deploying Your Application in Containers \\
What are containers? \\
Introduction to Docker \\
Running simple containers \\
Building your own images \\
Networking containers \\
Working with volumes \\
Building containers \\
Building containers for the backend services \\
Using static compilation for smaller images \\
Building containers for the frontend \\
Deploying your application with Docker Compose \\
Publishing your images \\
Deploying your application to the cloud \\
Introduction to Kubernetes \\
Setting up a local Kubernetes with Minikube \\
Core concepts of Kubernetes \\
Services \\
Persistent volumes \\
Deploying MyEvents to Kubernetes \\
Creating the RabbitMQ broker \\
Creating the MongoDB containers \\
Making images available to Kubernetes \\
Deploying the MyEvents components \\
Configuring HTTP Ingress \\
Summary \\
7: AWS I \\
Fundamentals, AWS SDK for Go, and EC2 \\
AWS fundamentals \\
The AWS console \\
AWS command-line interface (CLI) \\
AWS regions and zones \\
AWS tags \\
AWS Elastic Beanstalk \\
AWS services \\
AWS SDK for Go \\
Configuring the AWS region \\
Configuring AWS SDK authentication \\
Creating IAM Users \\
Creating IAM Roles \\
The fundamentals of the AWS SDK for Go \\
Sessions \\
Service clients \\
Native datatypes \\
Shared configuration \\
Pagination methods \\
Waiters \\
Handling Errors \\
Elastic Compute Cloud (EC2) \\
Creating EC2 instances \\
Accessing EC2 instances \\
Accessing EC2 instances from a Linux or macOS machine
\\
Accessing EC2 from Windows \\
Security groups \\
Summary \\
8: AWS II \\
S3, SQS, API Gateway, and DynamoDB \\
Simple Storage Service (S3) \\
Configuring S3 \\
Simple Queue Service (SQS) \\
AWS API gateway \\
DynamoDB \\
DynamoDB components \\
Attribute value data types \\
Primary keys \\
Secondary indexes \\
Creating tables \\
The Go language and DynamoDB \\
Summary \\
9: Continuous Delivery \\
Setting up your project \\
Setting up version control \\
Vendoring your dependencies \\
Using Travis CI \\
Deploying to Kubernetes \\
Using GitLab \\
Setting up GitLab \\
Setting up GitLab CI \\
Summary \\
10: Monitoring Your Application \\
Setting up Prometheus and Grafana \\
Prometheus's basics \\
Creating an initial Prometheus configuration file \\
Running Prometheus on Docker \\
Running Grafana on Docker \\
Exporting metrics \\
Using the Prometheus client in your Go application \\
Configuring Prometheus scrape targets \\
Exporting custom metrics \\
Running Prometheus on Kubernetes \\
Summary \\
11: Migration \\
What is a monolithic application? \\
What are microservices? \\
Migrating from monolithic applications to microservices
\\
Humans and technology \\
Cutting a monolithic application to pieces \\
How do we break the code? \\
Glue code \\
Microservices design patterns \\
Sacrificial architecture \\
A four-tier engagement platform \\
Bounded contexts in domain-driven designs \\
Data consistency \\
Event-driven architecture for data consistency \\
Events sourcing \\
CQRS \\
Summary \\
12: Where to Go from Here? \\
Microservices communications \\
Protocol buffers \\
GRPC \\
More on AWS \\
DynamoDB streams \\
Autoscaling on AWS \\
Amazon Relational Database Service \\
Other cloud providers \\
Microsoft Azure \\
Google Cloud PlatformOpenStack \\
Running containers in the cloud \\
Serverless architectures \\
Summary \\
Index",
}
@Book{Andrawos:2017:MGP,
author = "Mina Andrawos",
title = "Mastering Go Programming",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "1 streaming video file, approximately 20 hr., 13
min.",
year = "2017",
ISBN = "1-78646-823-9",
ISBN-13 = "978-1-78646-823-9",
LCCN = "????",
bibdate = "Thu Apr 22 10:04:32 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Master programming with Go by learning how to write
idiomatic, effective code About This Video Program like
a seasoned expert with one of the great new programming
languages Write idiomatic Go the right way, and
understand the fundamental mechanics of the language in
depth Understand how to develop powerful performant
applications and services with Go In Detail Go has
moved from the state of tentative to mass adoption. Its
C-like speed, simplicity, and power for a growing
number of systems level programming domains make it an
attractive option for programmers working with older
cumbersome, statically typed languages. Golang has
entered the space as an entirely viable language for
accomplishing a huge array of low level programming and
service infrastructure tasks. This video course not
only gives you a deep insight into the fundamental
mechanics behind the language, but also covers
extensive practical topics on Go for modern software
architectures. It shows you how to write Go in an
intelligent, idiomatic way. After a brief
re-acquaintance with the key building blocks of Go, we
will also explore how we can build upon the unique
capabilities of the language to write effective,
powerful code you can employ to develop software. We
look at packages, object-oriented programming,
concurrency and reflection among other things.
Moreover, you will learn about Go's awesome built-in
testing support feature. Along the way, build your
skills in File handling techniques, Go packages for
databases, data serialization approaches, message
communications between Go services, and Go web
applications. Get your hands on with a plenty of
illustrative code samples, exercises and real-world
scenarios that will help you build your own
application. By the end of this course, you will be
taught how to put this enhanced knowledge to build a
real-world Spaceship application all by yourself with
amazing features.",
acknowledgement = ack-nhfb,
subject = "Internet videos; Streaming video; Internet videos;
Streaming video.",
}
@Book{Andrawos:2017:MGPA,
author = "Mina Andrawos",
title = "Modern {Golang} Programming",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "1 streaming video file (14 hours, 37 minutes)",
year = "2017",
ISBN = "1-78712-525-4",
ISBN-13 = "978-1-78712-525-4",
LCCN = "????",
bibdate = "Thu Apr 22 09:59:38 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Learn how to use the Go language open source third
party ecosystem to build sophisticated production
applications About This Video Get practical overview of
the Go language Explore popular SQL databases such as
MySQL, PostgreSQL and SQLite Learn about the GORM ORM
layer Build Go applications that can work with Mongodb
Learn the concepts of time series databases with
InfluxDB Learn protocol buffers version 2 and 3 Explore
gRPC support in Go Dive into the Gorilla web toolkit,
REST APIs, Gorilla websockets, and Gorilla cookies
Understand the Hero templating engine In Detail Go is
the language of the Internet age, because it was built
from the ground up to support modern distributed web
software. Go is also cross-platform as it compiles to
numerous operating systems and CPU architectures via
simple commands. It compiles to native binaries, it
doesn't use a VM, and is garbage-collected, which makes
it a breeze to deploy in production environments.
Throughout the course, we will use modern open source
third party packages in Go to build a distributed
application that will support several databases,
establish efficient serial communications techniques,
and construct an advanced web layer with templates,
cookies, and websockets support. We will start with a
refresher on Go's primary building blocks. From there,
we will explore numerous open source packages that
allow working with a variety of databases in a
production environment as well as an ORM layer. We will
then explore building reliable and robust microservices
that communicate efficiently with each other via fast
serialization and RPC techniques. Finally, we will
develop knowledge on powerful third party templating
engines and web toolkits, to construct a modern web
layer with a RESTful API.",
acknowledgement = ack-nhfb,
subject = "Internet videos; Streaming video; Internet videos;
Streaming video.",
}
@Book{Balasubramanian:2017:IG,
author = "Kamesh Balasubramanian",
title = "Isomorphic {Go}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "505 (est.)",
year = "2017",
ISBN = "1-78839-418-6 (print)",
ISBN-13 = "978-1-78839-418-5 (print), 978-1-78839-880-0",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 11:01:12 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Learning about isomorphic development in Go leads to a
unified view of web and back-end development: It
extends the remit of a server-side programming language
to the browser. About This Book Learn how to build
Isomorphic Go web applications Neatly organize your
isomorphic codebase to enhance the maintainability of
your application Leverage the same Go code across the
web server and the web browser Who This Book Is For
This book addresses web developers, who are comfortable
with JavaScript and the full web development cycle. You
may or may not be experienced in isomorphic
development, but should have a basic understanding of
Go's syntax. What You Will Learn Create Go programs
inside the web browser using GopherJS Render isomorphic
templates on both the client side and the server side
Perform end-to-end application routing for greater
search engine discoverability and an enhanced user
experience Implement isomorphic handoff to seamlessly
transition state between the web server and the web
browser Build real-time web application functionality
with websockets Create reusable components (cogs) that
are rendered using the virtual DOM Deploy an Isomorphic
Go application for production use In Detail Isomorphic
Go is the methodology to create isomorphic web
applications using the Go programming language.
Isomorphic web applications have the capability to
reuse code across environments, increasing the synergy
between the web server and the web browser. This book
is a hands-on guide that will show you how to build and
deploy an Isomorphic Go web application. Isomorphic Go
begins with an in-depth exploration of the benefits
provided by the isomorphic web application
architecture. You'll be introduced to the Isomorphic Go
toolchain, and how it can help you write Go code that
functions across environments. You'll learn how to
create Go programs in the web browser using GopherJS
and how to render isomorphic templates. Then you'll be
introduced to end-to-end application routing, use
isomorphic handoff to seamlessly transition state from
the web server to the web browser, and compose
isomorphic forms that have the ability to reuse form
validation logic. You'll be exposed to advanced
concepts including the implementation of real-time web
application functionality with websockets and the
creation of reusable components (cogs) that are
rendered using the virtual DOM. Finally, you'll see how
to deploy an Isomorphic Go web application to a
production environment.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Go (Computer program
language)",
}
@Book{Hoffman:2017:CNG,
author = "Kevin Hoffman and Dan Nemeth",
title = "Cloud Native {Go}: Building {Web} Applications and
Microservices for the Cloud with {Go} and {React}",
publisher = "Addison-Wesley Professional",
address = "????",
pages = "256",
year = "2017",
ISBN = "0-13-450575-1 (e-book), 0-13-450578-6, 0-13-450580-8,
0-672-33779-7",
ISBN-13 = "978-0-13-450575-6 (e-book), 978-0-13-450578-7,
978-0-13-450580-0, 978-0-672-33779-6",
LCCN = "QA76.585",
bibdate = "Thu Apr 22 10:38:29 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://www.vlebooks.com/vleweb/product/openreader?id=none\%26isbn=9780134505800",
abstract = "The Complete Guide to Building Cloud-Based Services
Cloud Native Go shows developers how to build massive
cloud applications that meet the insatiable demands of
today's customers, and will dynamically scale to handle
virtually any volume of data, traffic, or users. Kevin
Hoffman and Dan Nemeth describe the modern cloud-native
application in detail, illuminating factors,
disciplines, and habits associated with rapid, reliable
cloud-native development. They also introduce Go, a
``simply elegant'' high-performance language that is
especially well-suited for cloud development. You'll
walk through creating microservices in Go, adding
front-end web components using ReactJS and Flux, and
mastering advanced Go-based cloud-native techniques.
Hoffman and Nemeth show how to build a continuous
delivery pipeline with tools like Wercker, Docker, and
Dockerhub; automatically push apps to leading
platforms; and systematically monitor app performance
in production. Learn ``The Way of the Cloud'': why
developing good cloud software is fundamentally about
mindset and discipline Discover why Go is ideal for
cloud-native microservices development Plan cloud apps
that support continuous delivery and deployment Design
service ecosystems, and then build them in a test-first
manner Push work-in-progress to a cloud Use Event
Sourcing and CQRS patterns to react and respond to
enormous volume and throughput Secure cloud-based web
applications: do's, don'ts, and options Create reactive
applications in the cloud with third-party messaging
providers Build massive-scale, cloud-friendly GUIs with
React and Flux Monitor dynamic scaling, failover, and
fault tolerance in the cloud.",
acknowledgement = ack-nhfb,
subject = "Cloud computing; Cloud computing.",
}
@Book{Jackson:2017:BMG,
author = "Nic Jackson",
title = "Building Microservices with {Go}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "ix + 338",
year = "2017",
ISBN = "1-78646-866-2, 1-78646-979-0",
ISBN-13 = "978-1-78646-866-6, 978-1-78646-979-3",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 10:05:37 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Your one-stop guide to the common patterns and
practices, showing you how to apply these using the Go
programming language About This Book This short,
concise, and practical guide is packed with real-world
examples of building microservices with Go It is easy
to read and will benefit smaller teams who want to
extend the functionality of their existing systems
Using this practical approach will save your money in
terms of maintaining a monolithic architecture and
demonstrate capabilities in ease of use Who This Book
Is For You should have a working knowledge of
programming in Go, including writing and compiling
basic applications. However, no knowledge of RESTful
architecture, microservices, or web services is
expected. If you are looking to apply techniques to
your own projects, taking your first steps into
microservice architecture, this book is for you. What
You Will Learn Plan a microservice architecture and
design a microservice Write a microservice with a
RESTful API and a database Understand the common idioms
and common patterns in microservices architecture
Leverage tools and automation that helps microservices
become horizontally scalable Get a grounding in
containerization with Docker and Docker-Compose, which
will greatly accelerate your development lifecycle
Manage and secure Microservices at scale with
monitoring, logging, service discovery, and automation
Test microservices and integrate API tests in Go In
Detail Microservice architecture is sweeping the world
as the de facto pattern to build web-based
applications. Golang is a language particularly well
suited to building them. Its strong community,
encouragement of idiomatic style, and statically-linked
binary artifacts make integrating it with other
technologies and managing microservices at scale
consistent and intuitive. This book will teach you the
common patterns and practices, showing you how to apply
these using the Go programming language. It will teach
you the fundamental concepts of architectural design
and RESTful communication, and show you patterns that
provide manageable code that is supportable in
development and at scale in production. We will provide
you with examples on how to put these concepts and
patterns into practice with Go. Whether you are
planning a new application or working in an existing
monolith, this book will explain and illustrate with
practical examples how teams of all sizes can start
solving problems with microservices. It will help you
unders.",
acknowledgement = ack-nhfb,
tableofcontents = "Preface \\
1: Introduction to Microservices \\
Building a simple web server with net/http \\
Reading and writing JSON \\
Marshalling Go structs to JSON \\
Unmarshalling JSON to Go structs \\
Routing in net/http \\
Paths \\
Convenience handlers \\
FileServer \\
NotFoundHandler \\
RedirectHandler \\
StripPrefix \\
TimeoutHandler \\
Static file handler \\
Creating handlers \\
Context \\
Background \\
WithCancel \\
WithDeadline \\
WithTimeout \\
WithValue \\
Using contexts \\
RPC in the Go standard library \\
Simple RPC example \\
RPC over HTTP \\
JSON-RPC over HTTP \\
Summary \\
2: Designing a Great API \\
RESTful APIs \\
URIs \\
URI format \\
URI path design for REST services \\
Collections \\
Documents \\
Controller \\
Store \\
CRUD function names \\
HTTP verbs \\
GET \\
POST \\
PUT \\
PATCH \\
DELETE \\
HEAD \\
OPTIONS \\
URI query design \\
Response codes \\
2xx Success \\
200 OK \\
201 Created \\
204 No Content \\
3xx Redirection \\
301 Moved Permanently \\
304 Not Modified \\
4xx Client Error \\
400 Bad Request \\
401 Unauthorized \\
403 Forbidden \\
404 Not Found \\
405 Method Not Allowed \\
408 Request Timeout \\
5xx Server Error \\
500 Internal Server Error \\
503 Service Unavailable \\
HTTP headers \\
Standard request headers \\
Authorization \\
string \\
Date \\
Accept \\
content type \\
Accept-Encoding \\
gzip, deflate \\
Standard response headers \\
Returning errors \\
Accessing APIs from JavaScript \\
JSONP \\
CORS \\
RPC APIs \\
RPC API design \\
RPC message frameworks \\
Gob \\
Thrift \\
Protocol Buffers \\
JSON-RPC \\
Filtering \\
Versioning APIs \\
Semantic versioning \\
Versioning formats for REST APIs \\
Versioning formats for RPC APIs \\
Naming for RPC \\
Object type standardization \\
Dates \\
Durations \\
Intervals \\
Documenting APIs \\
REST based-based APIs \\
Swagger \\
API Blueprint \\
RAMLRPC based-based APIs \\
Summary \\
3: Introducing Docker \\
Introducing Containers with Docker \\
Installing Docker \\
Running our first container \\
Docker volumes \\
Union filesystem \\
Mounting volumes \\
Docker ports \\
Removing a container starting with an explicit name \\
Docker networking \\
Bridge networking \\
Host networking \\
No network \\
Overlay network \\
Custom network drivers \\
Weaveworks \\
Project Calico \\
Creating custom bridge networks \\
Creating a bridge network \\
Connecting containers to a custom network \\
Writing Dockerfiles \\
Building application code for Docker \\
FROM \\
MAINTAINER \\
EXPOSE \\
COPYENTRYPOINTCMD \\
Good practice for creating Dockerfiles \\
Building images from Dockerfiles \\
Docker build context \\
Docker Ignore files \\
Running Daemons in containers \\
Docker Compose \\
Installing Docker Compose on Linux \\
Service startup \\
Specifying the location of a compose file \\
Specifying a project name \\
Summary \\
4: Testing \\
The testing pyramid \\
Outside-in development \\
Unit tests \\
httptest.NewRequest \\
httptest.NewRecorder \\
Dependency injection and mocking \\
Code coverage \\
Behavioral Driven Development \\
Testing with Docker Compose \\
Benchmarking and profiling \\
Benchmarks \\
Profiling \\
Summary",
}
@Book{Kennedy:2017:UGP,
author = "William Kennedy",
title = "Ultimate {Go} Programming",
publisher = "Addison-Wesley Professional",
pages = "1 video file (14 hours, 51 minutes)",
year = "2017",
ISBN = "0-13-475747-5",
ISBN-13 = "978-0-13-475747-6",
LCCN = "????",
bibdate = "Thu Apr 22 10:15:33 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "15+ Hours of Video Instruction Ultimate Go Programming
LiveLessons provides an intensive, comprehensive, and
idiomatic view of the Go programming language. This
course focuses on both the specification and
implementation of the language, including topics
ranging from language syntax, design, and guidelines to
concurrency, testing, and profiling. This class is
perfect for anyone who wants a jump-start in learning
Go or wants a more thorough understanding of the
language and its internals. In this video training,
Bill Kennedy starts by providing a deep and intensive
dive into Go's language syntax, idioms, implementation,
and specification. Then Bill guides you through the
essential things you need to know about designing
software in Go. With that strong foundation, Bill then
teaches the language mechanics behind Go's concurrency
primitives and covers all the things you need to know
to design concurrent software. Finally, Bill covers the
tooling Go provides for testing, tracing, and profiling
your programs. About the Instructor William Kennedy is
a managing partner at Ardan Studio in Miami, Florida, a
mobile, web, and systems development company. He is
also a coauthor of the book Go in Action, the author of
the blog ``GoingGo.Net,'' and a founding member of
GoBridge, which is working to increase Go adoption
through embracing diversity. Skill Level Intermediate
What You Will Learn Language mechanics and internals
Data structures and mechanical sympathy Software design
and best practices Project structure and design
Concurrent software design Testing and benchmarking
Tracing and profiling Who Should Take This Course Any
intermediate-level developer who has some experience
with other programming languages and wants to learn Go.
This video is perfect for anyone who wants a jump-start
in learning Go or wants a more thorough understanding
of the language, its internals and how to design
software. Course Requirements Studied CS in school or
has a minimum of two years of experience programming
full time professionally. Familiar with structural and
object-oriented programming styles. Has worked with
arrays, lists, queues and stacks. Understands
processes, threads and synchronization at a high level.
Operating Systems Has worked with a command shell Knows
how to maneuver around the file system Understands what
environment variables are About Pearson Video Training
Pearson publishes expert-led video tutorials covering a
wide selection of technology topics \ldots{}",
acknowledgement = ack-nhfb,
subject = "Internet videos; Streaming video; Internet videos;
Streaming video.",
}
@Book{Ketelsen:2017:TG,
author = "Brian Ketelsen",
title = "Testing in Go",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "1 video file (25 minutes)",
year = "2017",
ISBN = "1-4919-7276-9, 1-4919-7277-7",
ISBN-13 = "978-1-4919-7276-2, 978-1-4919-7277-9",
LCCN = "????",
bibdate = "Thu Apr 22 10:46:40 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Having access to a reliable and comprehensive test
suite for your applications isn't a luxury anymore-it's
a requirement. This video is the first in a series of
``Testing in Go'' videos that teach you how to test
your Go applications and make certain that what you
ship works the first time. Designed for basic or
intermediate level Go developers who want to start
writing tests, write better tests, or increase the
coverage of their current test suites, this course
provides complete step-by-step instruction on how to
write testable code. Learn all about Go's testing
package and tools Understand how to test code in Go
with internal tests Explore the mechanics of writing
tests for your Go code Discover how to simplify your Go
test cases by using table-driven tests Get exposed to
Go's external tests and their usage Learn to scope
tests to cover your code and not the code in the
standard library or other packages Brian Ketelsen is
the founder of the Gopher Academy, the parent group
that manages GopherCon, the Go programming language
conference. A prolific open source enthusiast, he has
contributed to many of Go's largest projects, including
Docker, Kubernetes, etcd, SkyDNS, Kong, Go-Kit, and
Goa. Brian holds a bachelor's degree in computer
science from American InterContinental University.",
acknowledgement = ack-nhfb,
subject = "Internet videos; Streaming video; Internet videos;
Streaming video.",
}
@Article{Kortschak:2017:PBOa,
author = "R. Daniel Kortschak and Brent S. Pedersen and David L.
Adelson",
title = "\pkg{b{\'\i}ogo/hts}: high throughput sequence
handling for the {Go} language",
journal = j-J-OPEN-SOURCE-SOFT,
volume = "2",
number = "10",
pages = "168:1--168:1",
month = feb,
year = "2017",
CODEN = "????",
DOI = "https://doi.org/10.21105/joss.00168",
ISSN = "2475-9066",
ISSN-L = "2475-9066",
bibdate = "Thu Sep 13 08:09:35 MDT 2018",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/joss.bib",
URL = "http://joss.theoj.org/papers/10.21105/joss.00168",
acknowledgement = ack-nhfb,
fjournal = "Journal of Open Source Software",
journal-URL = "http://joss.theoj.org/;
https://github.com/openjournals/joss-papers/",
onlinedate = "04 February 2017",
ORCID-numbers = "R Daniel Kortschak / 0000-0001-8295-2301; Brent S.
Pedersen / 0000-0003-1786-2216; David L. Adelson /
0000-0003-2404-5636",
}
@Article{Kortschak:2017:PBOb,
author = "R. Daniel Kortschak and David L. Adelson",
title = "\pkg{b{\'\i}ogo/ncbi}: interfaces to {NCBI} services
for the {Go} language",
journal = j-J-OPEN-SOURCE-SOFT,
volume = "2",
number = "18",
pages = "234:1--234:2",
month = oct,
year = "2017",
CODEN = "????",
DOI = "https://doi.org/10.21105/joss.00234",
ISSN = "2475-9066",
ISSN-L = "2475-9066",
bibdate = "Thu Sep 13 08:09:35 MDT 2018",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/joss.bib",
URL = "http://joss.theoj.org/papers/10.21105/joss.00234",
acknowledgement = ack-nhfb,
fjournal = "Journal of Open Source Software",
journal-URL = "http://joss.theoj.org/;
https://github.com/openjournals/joss-papers/",
onlinedate = "25 October 2017",
ORCID-numbers = "R Daniel Kortschak / 0000-0001-8295-2301; David L.
Adelson / 0000-0003-2404-5636",
}
@Book{Newmarch:2017:NPG,
author = "Jan Newmarch",
title = "Network Programming with {Go}: Essential Skills for
Using and Securing Networks",
publisher = pub-APRESS,
address = pub-APRESS:adr,
pages = "xxi + 274 + 36",
year = "2017",
DOI = "https://doi.org/10.1007/978-1-4842-2692-6",
ISBN = "1-4842-2691-7, 1-4842-2692-5",
ISBN-13 = "978-1-4842-2691-9, 978-1-4842-2692-6",
LCCN = "QA76.73.G63 N48 2017; QA76.76.C65",
bibdate = "Thu Apr 22 10:44:51 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Dive into key topics in network architecture and Go,
such as data serialization, application level
protocols, character sets and encodings. This book
covers network architecture and gives an overview of
the Go language as a primer, covering the latest Go
release. Beyond the fundamentals, Network Programming
with Go covers key networking and security issues such
as HTTP and HTTPS, templates, remote procedure call
(RPC), web sockets including HTML5 web sockets, and
more. Additionally, author Jan Newmarch guides you in
building and connecting to a complete web server based
on Go. This book can serve as both as an essential
learning guide and reference on Go networking. What You
Will Learn Master network programming with Go Carry out
data serialization Use application-level protocols
Manage character sets and encodings Deal with HTTP(S)
Build a complete Go-based web server Work with RPC, web
sockets, and more Who This Book Is For Experienced Go
programmers and other programmers with some experience
with the Go language.",
acknowledgement = ack-nhfb,
subject = "Computer science; Computer networks; Computer
programming; Programming languages (Electronic
computers); Programming Languages, Compilers,
Interpreters; Programming Techniques; Computer
Communication Networks; Computer Science
(Springer-11645); Computer networks; Computer
programming; Computer science; Programming languages
(Electronic computers)",
tableofcontents = "1. Architecture \\
2. Overview of the Go language \\
3. Socket-level Programming \\
4. Data Serialization \\
5. Application-Level Protocols \\
6. Managing character sets and encodings \\
7. Security \\
8. HTTP \\
9. Templates \\
10. A Complete Web Server \\
11. HTML \\
12. XML \\
13. Remote Procedure Call \\
14. REST \\
15. Web Sockets \\
Afterword",
}
@Book{Rice:2017:HCY,
author = "Liz Rice",
title = "How to Containerize Your {Go} Code",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "????",
year = "2017",
ISBN = "1-4919-8230-6",
ISBN-13 = "978-1-4919-8230-3",
LCCN = "????",
bibdate = "Thu Apr 22 11:02:53 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/ora.bib",
acknowledgement = ack-nhfb,
}
@InProceedings{Sartori:2017:GFM,
author = "Marcos L. L. Sartori and Ney L. V. Calazans",
editor = "{IEEE}",
booktitle = "{2017 24th IEEE International Conference on
Electronics, Circuits and Systems (ICECS)}",
title = "{Go} functional model for a {RISC-V} asynchronous
organisation --- {ARV}",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "381--348",
year = "2017",
DOI = "https://doi.org/10.1109/ICECS.2017.8292066",
bibdate = "Sat Dec 16 15:51:40 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/risc-v.bib",
acknowledgement = ack-nhfb,
}
@Book{Torres:2017:GCB,
author = "Aaron Torres",
title = "{Go} cookbook: build modular, readable, and testable
applications in {Go}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "392 (est.)",
year = "2017",
ISBN = "1-78328-684-9",
ISBN-13 = "978-1-78328-683-6, 978-1-78328-684-3",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 10:42:24 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Application software;
Development; Development; Go (Computer program
language)",
}
@Book{Valentine:2017:CGG,
author = "DaveIn Valentine",
title = "The complete {Google Go} programming course for
beginners",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "1 streaming video file (4 hours, 50 minutes)",
year = "2017",
ISBN = "1-78862-697-4",
ISBN-13 = "978-1-78862-697-2",
LCCN = "????",
bibdate = "Thu Apr 22 10:50:15 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Our goal for you in this course is: For you to become
a beginner Ninja in one of the hottest new languages
called ``Google Go'' and also known as Golang. Google
go is taking the development world by storm, because of
its system level access and its design which gives
programmers the ability to create multi-core programs.
This is the first development language really developed
for the type of multi-core CPU computers that have been
in the market for the last ten years. Created by three
genius developers are Google - to solve deficiencies
Google was experiencing with conventional computer
languages. This course is especially structured to
solve a number of problems that introductions to
programming languages suffer form.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Computer programming;
Application software; Development; Electronic videos;
local",
}
@Book{Vivien:2017:GDP,
author = "Vladimir Vivien and Mario Contreras and Mat Ryer",
title = "{Go}: Design Patterns for Real-World Projects",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "1091",
year = "2017",
ISBN = "1-78839-055-5, 1-78839-287-6",
ISBN-13 = "978-1-78839-055-2, 978-1-78839-287-7",
LCCN = "????",
bibdate = "Thu Apr 22 10:14:18 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "An insightful guide to learning the Go programming
language About This Book Get insightful coverage of Go
programming syntax, constructs, and idioms to help you
understand Go code Get a full explanation of all the
known GoF design patterns in Go, including
comprehensive theory and examples Learn to apply the
nuances of the Go language, and get to know the open
source community that surrounds it to implement a wide
range of start-up quality projects Who This Book Is For
Beginners to Go who are comfortable in other OOP
languages like Java, C\#, or Python will find this
course interesting and beneficial. What You Will Learn
Install and configure the Go development environment to
quickly get started with your first program Use the
basic elements of the language including source code
structure, variables, constants, and control flow
primitives Get to know all the basic syntax and tools
you need to start coding in Go Create unique instances
that cannot be duplicated within a program Build quirky
and fun projects from scratch while exploring patterns,
practices, and techniques, as well as a range of
different technologies Create websites and data
services capable of massive scaling using Go's net/http
package, Explore RESTful patterns as well as
low-latency WebSocket APIs Interact with a variety of
remote web services to consume capabilities, ranging
from authentication and authorization to a fully
functioning thesaurus In Detail 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.",
}
@Book{Whitenack:2017:MLG,
author = "Daniel Whitenack",
title = "Machine Learning With Go",
publisher = "Packt Publishing; O'Reilly Media Inc.",
address = "[Erscheinungsort nicht ermittelbar]; Sebastopol, CA",
pages = "287 (??)",
year = "2017",
ISBN = "1-78588-210-4, 1-78588-390-9",
ISBN-13 = "978-1-78588-210-4, 978-1-78588-390-3",
LCCN = "QA76.73.G63 W55 2017",
bibdate = "Thu Apr 22 10:41:17 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Build simple, maintainable, and easy to deploy machine
learning applications. About This Book Build simple,
but powerful, machine learning applications that
leverage Go's standard library along with popular Go
packages. Learn the statistics, algorithms, and
techniques needed to successfully implement machine
learning in Go Understand when and how to integrate
certain types of machine learning model in Go
applications. Who This Book Is For This book is for Go
developers who are familiar with the Go syntax and can
develop, build, and run basic Go programs. If you want
to explore the field of machine learning and you love
Go, then this book is for you! Machine Learning with Go
will give readers the practical skills to perform the
most common machine learning tasks with Go. Familiarity
with some statistics and math topics is necessary. What
You Will Learn Learn about data gathering,
organization, parsing, and cleaning. Explore matrices,
linear algebra, statistics, and probability. See how to
evaluate and validate models. Look at regression,
classification, clustering. Learn about neural networks
and deep learning Utilize times series models and
anomaly detection. Get to grip with techniques for
deploying and distributing analyses and models.
Optimize machine learning workflow techniques In Detail
The mission of this book is to turn readers into
productive, innovative data analysts who leverage Go to
build robust and valuable applications. To this end,
the book clearly introduces the technical aspects of
building predictive models in Go, but it also helps the
reader understand how machine learning workflows are
being applied in real-world scenarios. Machine Learning
with Go shows readers how to be productive in machine
learning while also producing applications that
maintain a high level of integrity. It also gives
readers patterns to overcome challenges that are often
encountered when trying to integrate machine learning
in an engineering organization. The readers will begin
by gaining a solid understanding of how to gather,
organize, and parse real-work data from a variety of
sources. Readers will then develop a solid statistical
toolkit that will allow them to quickly understand gain
intuition about the content of a dataset. Finally, the
readers will gain hands-on experience implementing
essential machine learning techniques (regression,
classification, clustering, and so on) with the
relevant Go packages. Finally, the reader will have a
solid \ldots{}",
acknowledgement = ack-nhfb,
}
@Book{Aggarwal:2018:GWD,
author = "Arpit Aggarwal",
title = "{Go} web development cookbook: build full-stack web
applications with {Go}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "viii + 321",
year = "2018",
ISBN = "1-78728-674-6, 1-78728-856-0",
ISBN-13 = "978-1-78728-674-0, 978-1-78728-856-0",
LCCN = "QA76.73.G63; QA76.76.A65 .A343 2018",
bibdate = "Thu Apr 22 10:16:48 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Go is an open source programming language that is
designed to scale and support concurrency at the
language level. This gives you the liberty to write
large concurrent web applications with ease. From
creating web application to deploying them on Amazon
Cloud Services, this book will be your one-stop guide
to learn web development in Go.",
subject = "Go (Computer program language); Web applications;
Application software; Development; Application program
interfaces (Computer software); Application program
interfaces (Computer software); Development; Go
(Computer program language); Web applications.",
tableofcontents = "Preface \\
1: Creating Your First Server in Go \\
Introduction \\
Creating a simple HTTP server \\
How to do it \ldots{} \\
How it works \ldots{} \\
Implementing basic authentication on a simple HTTP
server \\
Getting ready \\
How to do it \ldots{} \\
How it works \ldots{} \\
Optimizing HTTP server responses with GZIP compression
\\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating a simple TCP server \\
How to do it \ldots{} \\
How it works \ldots{} \\
Reading data from a TCP connection \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Writing data to a TCP connection \\
Getting ready How to do it \ldots{} How it works
\ldots{} \\
Implementing HTTP request routing \\
How to do it \ldots{} \\
How it works \ldots{} \\
Implementing HTTP request routing using Gorilla Mux \\
How to do it \ldots{} \\
How it works \ldots{} \\
Logging HTTP requests \\
Getting Ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
2: Working with Templates, Static Files, and HTML Forms
\\
Introduction \\
Creating your first template \\
How to do it \ldots{} \\
How it works \ldots{} \\
Serving static files over HTTP \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Serving static files over HTTP using Gorilla Mux \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first HTML form \\
How to do it \ldots{} \\
How it works \ldots{} \\
Reading your first HTML form \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Validating your first HTML form \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Uploading your first file \\
How to do it \ldots{} \\
How it works \ldots{} \\
3: Working with Sessions, Error Handling, and Caching
in Go \\
Introduction \\
Creating your first HTTP session \\
How to do it \ldots{} \\
How it works \ldots{} \\
Managing your HTTP session using Redis \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first HTTP cookie \\
How to do it \ldots{} \\
How it works \ldots{} \\
Implementing caching in Go \\
How to do it \ldots{} \\
How it works Implementing HTTP error handling in GoHow
to do it \ldots{} \\
How it works \ldots{} \\
Implementing login and logout in web application \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
4: Writing and Consuming RESTful Web Services in Go \\
Introduction \\
Creating your first HTTP GET method \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first HTTP POST method \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first HTTP PUT method \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first HTTP DELETE method \\
How to do it \ldots{} \\
How it works \ldots{} \\
Versioning your REST API \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first REST client \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first AngularJS Client \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first ReactJS client \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first VueJS client \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
5: Working with SQL and NoSQL Databases \\
Introduction \\
Integrating MySQL and Go \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Creating your first record in MySQL \\
Getting ready \ldots{} \\
How to do it \ldots{} \\
How it works \ldots{} \\
Reading records from MySQL \\
How to do it \ldots{} \\
How it works",
}
@Book{Ball:2018:WIG,
author = "Thorsten Ball",
title = "Writing an Interpreter in {Go}: version 1.6",
publisher = "Thorsten Ball",
address = "????",
pages = "263",
year = "2018",
ISBN = "3-9820161-1-8 (paperback)",
ISBN-13 = "978-3-9820161-1-5 (paperback)",
LCCN = "QA76.76.C65 .B35 2018",
bibdate = "Mon Sep 20 07:33:32 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/master.bib",
abstract = "In this book we will create a programming language
together. We'll start with 0 lines of code and end up
with a fully working interpreter for the Monkey
programming language. Step by step. From tokens to
output. All code shown and included. Fully tested.",
acknowledgement = ack-nhfb,
shorttableofcontents = "Introduction \\
Lexing \\
Parsing \\
Evaluation \\
Extending the interpreter \\
Going further",
subject = "Interpreters (Computer programs); Study and teaching;
Programming languages (Electronic computers); Computer
programs; Computer software; Computer programs;
Computer software; Study and teaching",
tableofcontents = "Acknowledgments / 5 \\
Introduction / 6 \\
The Monkey Programming Language \& Interpreter / 8 \\
Why Go? / 10 \\
How to Use this Book / 11 \\
1 Lexing / 13 \\
1.1 Lexical Analysis / 13 \\
1.2 Defining Our Tokens / 15 \\
1.3 The Lexer / 17 \\
1.4 Extending our Token Set and Lexer / 27 \\
1.5 Start of a REPL / 33 \\
2 Parsing / 36 \\
2.1 Parsers / 36 \\
2.2 Why not a parser generator? / 39 \\
2.3 Writing a Parser for the Monkey Programming
Language / 41 \\
2.4 Parser's first steps: parsing let statements / 41
\\
2.5 Parsing Return Statements / 56 \\
2.6 Parsing Expressions / 59 \\
Expressions in Monkey / 60 \\
Top Down Operator Precedence (or Pratt Parsing) / 61
\\
Terminology / 62 \\
Preparing the AST / 63 \\
Implementing the Pratt Parser / 67 \\
Identifiers / 68 \\
Integer Literals / 72 \\
Prefix Operators / 75 \\
Infix Operators / 81 \\
2.7 How Pratt Parsing Works / 88 \\
2.8 Extending the Parser / 99 \\
Boolean Literals / 101 \\
Grouped Expressions / 105 \\
If Expressions / 107 \\
Function Literals / 113 \\
Call Expressions / 119 \\
Removing TODOs / 124 \\
2.9 Read-Parse-Print-Loop / 126 \\
3 Evaluation / 130 \\
3.1 Giving Meaning to Symbols / 130 \\
3.2 Strategies of Evaluation / 131 \\
3.3 A Tree-Walking Interpreter / 133 \\
3.4 Representing Objects / 135 \\
Foundation of our Object System / 136 \\
Integers / 137 \\
Booleans / 138 \\
Null / 138 \\
3.5 Evaluating Expressions / 139 \\
Integer Literals / 140 \\
15 Completing the REPL / 143 \\
Boolean Literals / 145 \\
Null / 147 \\
Prefix Expressions / 147 \\
Infix Expressions / 151 \\
3.6 Conditionals / 157 \\
3.7 Return Statements / 161 \\
3.8 Abort! Abort! There's been a mistake!, or: Error
Handling / 165 \\
3.9 Bindings \& The Environment / 172 \\
3.10 Functions \& Function Calls / 177 \\
3.11 Who's taking the trash out? / 189 \\
4 Extending the Interpreter / 192 \\
4.1 Data Types \& Functions / 192 \\
4.2 Strings / 193 \\
Supporting Strings in our Lexer / 193 \\
Parsing Strings / 196 \\
Evaluating Strings / 197 \\
String Concatenation / 199 \\
4.3 Built-in Functions / 201 \\
len / 202 \\
4.4 Array / 207 \\
Supporting Arrays in our Lexer / 208 \\
Parsing Array Literals / 210 \\
Parsing Index Operator Expressions / 213 \\
Evaluating Array Literals / 217 \\
Evaluating Index Operator Expressions / 219 \\
Adding Built-in Functions for Arrays / 223 \\
Test-Driving Arrays / 227 \\
4.5 Hashes / 228 \\
Lexing Hash Literals / 229 \\
Parsing Hash Literals / 231 \\
Hashing Objects / 236 \\
Evaluating Hash Literals / 242 \\
Evaluating Index Expressions With Hashes / 245 \\
4.6 The Grand Finale / 249 \\
Going Further / 252 \\
The Lost Chapter / 252 \\
Writing A Compiler In Go / 253 \\
Resources / 254 \\
Feedback / 257 \\
Changelog / 285",
}
@Book{Chew:2018:GML,
author = "Xuanyi Chew",
title = "{Go} machine learning projects: eight projects
demonstrating end-to-end machine learning and
predictive analytics applications in {Go}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "339",
year = "2018",
ISBN = "1-78899-340-3, 1-78899-519-8",
ISBN-13 = "978-1-78899-340-1, 978-1-78899-519-1",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 10:40:28 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Machine learning; Go
(Computer program language); Machine learning.",
}
@Book{Daniel:2018:SG,
author = "John Leon Daniel",
title = "Security with {Go}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
year = "2018",
ISBN = "1-78862-791-1",
ISBN-13 = "978-1-78862-791-7",
LCCN = "QA76.585 .L466 2018; QA76.59",
bibdate = "Thu Apr 22 10:33:25 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "The first stop for your security needs when using Go,
covering host, network, and cloud security for ethical
hackers and defense against intrusion About This Book
First introduction to Security with Golang Adopting a
Blue Team/Red Team approach Take advantage of speed and
inherent safety of Golang Works as an introduction to
security for Golang developers Works as a guide to
Golang security packages for recent Golang beginners
Who This Book Is For Security with Go is aimed at
developers with basics in Go to the level that they can
write their own scripts and small programs without
difficulty. Readers should be familiar with security
concepts, and familiarity with Python security
applications and libraries is an advantage, but not a
necessity. What You Will Learn Learn the basic concepts
and principles of secure programming Write secure
Golang programs and applications Understand classic
patterns of attack Write Golang scripts to defend
against network-level attacks Learn how to use Golang
security packages Apply and explore cryptographic
methods and packages Learn the art of defending against
brute force attacks Secure web and cloud applications
In Detail Go is becoming more and more popular as a
language for security experts. Its wide use in server
and cloud environments, its speed and ease of use, and
its evident capabilities for data analysis, have made
it a prime choice for developers who need to think
about security. Security with Go is the first Golang
security book, and it is useful for both blue team and
red team applications. With this book, you will learn
how to write secure software, monitor your systems,
secure your data, attack systems, and extract
information. Defensive topics include cryptography,
forensics, packet capturing, and building secure web
applications. Offensive topics include brute force,
port scanning, packet injection, web scraping, social
engineering, and post exploitation techniques. Style
and approach John Leon has divided the book into two
parts which present the team playing defense against
anyone breaking into servers and the team playing
(ethical!) offense to perform said attacks. All Go
scripts and programs are workable solutions that can be
easily understood and expanded upon by anyone with a
system administrator's level view of networking and
cloud-based systems. Golang developers will profit from
a swift and incisive approach to security. Downloading
the example code for this book You can download the
\ldots{}",
acknowledgement = ack-nhfb,
remark = "Title from content provider.",
subject = "Information technology; Security measures; Computer
security; Management; Computer networks; Data
protection; Security measures; Management; Data
protection.",
tableofcontents = "Preface \\
1: Introduction to Security with Go \\
About Go \\
Go language design \\
The History of Go \\
Adoption and community \\
Common criticisms about Go \\
The Go toolchain \\
Go mascot \\
Learning Go \\
Why use Go? \\
Why use Go for security? \\
Why not use Python? \\
Why not use Java? \\
Why not use C++? \\
Development environment \\
Installing Go on other platforms \\
Other Linux distributions \\
Windows \\
Mac \\
Setting up Go \\
Creating your workspace \\
Setting up environment variables \\
Editors \\
Creating your first package \\
Writing your first program \\
Running the executable file \\
Building the executable file \\
Installing the executable file \\
Formatting with go fmt \\
Running Go examples \\
Building a single Go file \\
Running a single Go file \\
Building multiple Go files \\
Building a folder (package) \\
Installing a program for use \\
Summary \\
2: The Go Programming Language \\
Go language specification \\
The Go playground \\
A tour of Go \\
Keywords \\
Notes about source code \\
Comments \\
Types \\
Boolean \\
Numeric \\
Generic numbers \\
Specific numbers \\
Unsigned integers \\
Signed integers \\
Floating point numbers \\
Other numeric types \\
String \\
Array \\
Slice \\
Struct \\
Pointer \\
Function \\
Interface \\
Map \\
Channel \\
Control structures \\
if \\
for \\
range \\
switch, case, fallthrough, and default \\
goto \\
Defer \\
Packages \\
Classes \\
Inheritance \\
Polymorphism \\
Constructors \\
Methods \\
Operator overloading \\
Goroutines \\
Getting help and documentation \\
Online Go documentation \\
Offline Go documentation \\
Summary \\
3: Working with Files \\
File basics \\
Creating an empty file \\
Truncating a file \\
Getting the file info \\
Renaming a file \\
Deleting a file \\
Opening and closing files \\
Checking whether a file exists \\
Checking read and write permissions \\
Changing permissions, ownership, and timestamps \\
Hard links and symlinks \\
Reading and writing \\
Copying a file \\
Seeking positions in a file \\
Writing bytes to a file \\
Quickly writing to a file \\
Buffered writer \\
Reading up to n bytes from a file \\
Reading exactly n bytes \\
Reading at least n bytes \\
Reading all bytes of a file \\
Quickly reading whole files to memory \\
Buffered reader \\
Reading with a scanner \\
Archives \\
Archive (ZIP) files \\
Extracting (unzip) archived files \\
Compression \\
Compressing a file \\
Uncompressing a File \\
Creating temporary files and directories \\
Downloading a file over HTTP \\
Summary \\
4: Forensics \\
Files \\
Getting file information \\
Finding the largest files \\
Finding recently modified files \\
Reading the boot sector \\
Steganography \\
Generating an image with random noise \\
Creating a ZIP archive \\
Creating a steganographic image archive \\
Detecting a ZIP archive in a JPEG image \\
Network \\
Looking up a hostname from an IP address \\
Looking up IP addresses from a hostname \\
Looking up MX records \\
Looking up nameservers for a hostname \\
Summary \\
5: Packet Capturing and Injection \\
Prerequisites \\
Installing libpcap and Git \\
Installing libpcap on Ubuntu \\
Installing libpcap on Windows \\
Installing libpcap on macOS \\
Installing gopacket \\
Permission problems \\
Getting a list of network devices \\
Capturing packets \\
Capturing with filters \\
Saving to the pcap file \\
Reading from a pcap file \\
Decoding packet layers \\
Creating a custom layer \\
Converting bytes to and from packets \\
Creating and sending packets \\
Decoding packets faster \\
Summary \\
6: Cryptography \\
Hashing \\
Hashing small files \\
Hashing large files \\
Storing passwords securely \\
Encryption \\
Cryptographically secure pseudo-random number generator
(CSPRNG) \\
Symmetric encryption \\
AES \\
Asymmetric encryption \\
Generating a public and private key pair \\
Digitally signing a message \\
Verifying a signature \\
TLS \\
Generating a self-signed certificate \\
Creating a certificate signing request \\
Signing a certificate request \\
TLS server \\
TLS client \\
Other encryption packages \\
OpenPGP \\
Off The Record (OTR) messaging \\
Summary \\
7: Secure Shell (SSH) \\
Using the Go SSH client \\
Authentication methods \\
Authenticating with a password \\
Authenticating with private key \\
Verifying remote host \\
Executing a command over SSH \\
Starting an interactive shell \\
Summary \\
8: Brute Force \\
Brute forcing HTTP basic authentication \\
Brute forcing the HTML login form \\
Brute forcing SSH \\
Brute forcing database login \\
Summary \\
9: Web Applications \\
HTTP server \\
Simple HTTP servers \\
HTTP basic auth \\
Using HTTPS \\
Creating secure cookies \\
HTML escaping output \\
Middleware with Negroni \\
Logging requests \\
Adding secure HTTP headers \\
Serving static files \\
Other best practices \\
CSRF tokens \\
Preventing user enumeration and abuse \\
Registration \\
Login \\
Resetting the password \\
User profiles \\
Preventing LFI and RFI abuse \\
Contaminated files \\
HTTP client \\
The basic HTTP request \\
Using the client SSL certificate \\
Using a proxy \\
Using system proxy \\
Using a specific HTTP proxy \\
Using a SOCKS5 proxy (Tor) \\
Summary \\
10: Web Scraping \\
Web scraping fundamentals \\
Finding strings in HTTP responses with the strings
package \\
Using regular expressions to find email addresses in a
page \\
Extracting HTTP headers from an HTTP response \\
Setting cookies with an HTTP client \\
Finding HTML comments in a web page \\
Finding unlisted files on a web server \\
Changing the user agent of a request \\
Fingerprinting web application technology stacks \\
Fingerprinting based on HTTP response headers \\
Fingerprinting web applications \\
How to prevent fingerprinting of your applications \\
Using the goquery package for web scraping \\
Listing all hyperlinks in a page \\
Finding documents in a web page \\
Listing page title and headings \\
Crawling pages on the site that store the most common
words \\
Printing a list of external JavaScript files in a page
\\
Depth-first crawling \\
Breadth-first crawling \\
How to protect against web scraping \\
Summary \\
11: Host Discovery and Enumeration \\
TCP and UDP sockets \\
Creating a server \\
Creating a client \\
Port scanning \\
Grabbing a banner from a service \\
Creating a TCP proxy \\
Finding named hosts on a network \\
Fuzzing a network service \\
Summary \\
12: Social Engineering \\
Gathering intel via JSON REST API \\
Sending phishing emails with SMTP \\
Generating QR codes \\
Base64 encoding data \\
Honeypots \\
TCP honeypot \\
The TCP testing tool \\
HTTP POST form login honeypot \\
HTTP form field honeypots \\
Sandboxing \\
Summary \\
13: Post Exploitation \\
Cross compiling \\
Creating bind shells \\
Creating reverse bind shells \\
Creating web shells \\
Finding writable files \\
Changing file timestamp \\
Changing file permissions \\
Changing file ownership \\
Summary \\
14: Conclusions \\
Recapping the topics you have learned \\
More thoughts on the usage of Go \\
What I hope you take away from the book \\
Be aware of legal, ethical, and technical boundaries
\\
Where to go from here \\
Getting help and learning more \\
Another Book You May Enjoy \\
Leave a review \\
let other readers know what you think \\
Index",
}
@Book{Guney:2018:HG,
author = "Tarik Guney",
title = "Hands-on with {Go}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "1 streaming video file (2 hours, 26 minutes)",
year = "2018",
ISBN = "1-78913-251-7",
ISBN-13 = "978-1-78913-251-9",
LCCN = "????",
bibdate = "Thu Apr 22 10:35:33 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Learn Go programming with concise examples to many
common fundamental problems. About This Video Get
comfortable with Go with short, independent, and
concise videos. Overcome the most common challenges
with the practical knowledge catered by the each and
every tutorial. Never forget by watching pill-size
videos whenever you are in a hurry. In Detail Go has
moved from the state of tentative to mass adoption. Its
C-like speed, simplicity, and power for a growing
number of systems level programming domains make it an
attractive option for programmers working with older
cumbersome, statically typed languages. This course
will help you learn Go programming language by solving
commonly faced problems by developers in a Recipe
approach. You will start by installing Go binaries and
get familiar with tools to develop application. Then
you will manipulate with strings and then use them in
built in constructions and built-in function constructs
to create a complex value from two floating-point
values. Then you will learn to perform arithmetic
operation date and time along with parsing them from
string values. Whether you are an expert programmer or
a fresh starter, you will learn how various answers are
programmed in Go language, which will take you to the
next level in your mastering at Go. These recipes will
be from concurrency in Go, performing various web
programming tasks, doing system programming, reading
and writing files, and many fundamental Go programming
skills such as proper error handling, doing logging,
and so on. The code bundle for this video course is
available at
https://github.com/PacktPublishing/Hands-on-with-go.",
acknowledgement = ack-nhfb,
remark = "Not recommended for use on the libraries' public
computers.",
subject = "Internet videos; Streaming video; Internet videos;
Streaming video.",
}
@Book{Guney:2018:HGP,
author = "Tarik Guney",
title = "Hands-on {Go} programming: explore {Go} by solving
real-world challenges",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "iii + 166",
year = "2018",
ISBN = "1-78953-487-9 (e-book)",
ISBN-13 = "978-1-78953-175-6, 978-1-78953-487-0 (e-book)",
LCCN = "QA76.73.G63 G86 2018",
bibdate = "Thu Apr 22 10:53:01 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Computer programming;
COMPUTERS; Programming Languages; Java; Computer
programming; Go (Computer program language)",
}
@Book{Kennedy:2018:UGP,
author = "William Kennedy",
title = "Ultimate {Go} Programming",
publisher = "Addison-Wesley Professional",
edition = "Second",
pages = "1 video file (16 hours, 51 minutes)",
year = "2018",
ISBN = "0-13-526165-1",
ISBN-13 = "978-0-13-526165-1",
LCCN = "????",
bibdate = "Thu Apr 22 07:22:26 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "16+ Hours of Video Instruction Ultimate Go Programming
LiveLessons, Second Edition, provides an intensive,
comprehensive, and idiomatic view of the Go programming
language. This course focuses on both the specification
and implementation of the language, including topics
ranging from language syntax, design, and guidelines to
concurrency, testing, and profiling. This class is
perfect for anyone who wants a jump-start in learning
Go or wants a more thorough understanding of the
language and its internals. In this video training,
Bill Kennedy starts by providing a deep and intensive
dive into Go's language syntax, idioms, implementation,
and specification. Then Bill guides you through the
essential things you need to know about designing
software in Go. With that strong foundation, Bill then
teaches the language mechanics behind Go's concurrency
primitives and covers all the things you need to know
to design concurrent software. Finally, Bill covers the
tooling Go provides for testing, tracing, and profiling
your programs. About the Instructor William Kennedy is
a managing partner at Ardan Studio in Miami, Florida, a
mobile, web, and systems development company. He is
also a coauthor of the book Go in Action, the author of
the blog ``GoingGo.Net,'' and a founding member of
GoBridge, which is working to increase Go adoption
through embracing diversity. Skill Level Intermediate
Learn How To Read code with an understanding of the
language mechanics and internals Understand costs by
knowing the different semantics of the language Code
and design software more effectively Design your Go
projects and better ways to package your APIs Write
multithreaded code in Go and learn the things you need
to focus on Unit test your code and write benchmarks to
validate assumptions Profile and trace your Go programs
to identify and fix bugs and to make improvements Who
Should Take This Course Any intermediate-level
developer who has some experience with other
programming languages and wants to learn Go. This video
is perfect for anyone who wants a jump-start in
learning Go or wants a more thorough understanding of
the language, its internals and how to design software.
Course Requirements Studied CS in school or has a
minimum of two years of experience programming full
time professionally. Familiar with structural and
object-oriented programming styles. Has worked with
arrays, lists, queues and stacks. Understands
processes, threads and synchronization at a high
level.",
acknowledgement = ack-nhfb,
subject = "Internet videos; Streaming video; Internet videos;
Streaming video.",
}
@Article{Kortschak:2018:PAG,
author = "R. Daniel Kortschak",
title = "\pkg{arrgh}: a {Go} interface to the {OpenCPU} {R}
server system",
journal = j-J-OPEN-SOURCE-SOFT,
volume = "3",
number = "21",
pages = "517:1--517:1",
month = jan,
year = "2018",
CODEN = "????",
DOI = "https://doi.org/10.21105/joss.00517",
ISSN = "2475-9066",
ISSN-L = "2475-9066",
bibdate = "Thu Sep 13 08:09:35 MDT 2018",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/joss.bib;
https://www.math.utah.edu/pub/tex/bib/s-plus.bib",
URL = "http://joss.theoj.org/papers/10.21105/joss.00517",
acknowledgement = ack-nhfb,
fjournal = "Journal of Open Source Software",
journal-URL = "http://joss.theoj.org/;
https://github.com/openjournals/joss-papers/",
onlinedate = "15 January 2018",
ORCID-numbers = "R Daniel Kortschak / 0000-0001-8295-2301",
}
@InProceedings{Mladenovi:2018:ASM,
author = "Dragan Mladenovi{\c{c}} and Milan Kne{\v{z}}evi{\'c}
and Vladimir Stefanovi{\'c} and Milo{\v{s}}
Suboti{\'c}",
editor = "{IEEE}",
booktitle = "2018 26th Telecommunications Forum {(TELFOR)}",
title = "Adding Support for the {MIPS32} Architecture into the
{Go} Language Compiler",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "420--425",
year = "2018",
DOI = "https://doi.org/10.1109/TELFOR.2018.8612023",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
}
@Book{Ramalho:2018:PVG,
author = "Luciano Ramalho",
title = "{Python vs. Go}",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "????",
year = "2018",
ISBN = "1-4920-3317-0, 1-4920-3318-9",
ISBN-13 = "978-1-4920-3317-2, 978-1-4920-3318-9",
LCCN = "QA76.73.P98",
bibdate = "Thu Apr 22 10:36:31 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/python.bi",
abstract = "Comparing Python with Go is a bit like comparing an
SUV with a sports car: they were created to serve
different needs. Thanks to their simple syntax and
careful design, you will probably find Python and Go
easier to learn and use than other mainstream languages
that you might have already studied. Given their gentle
learning curve and phenomenal growth in several fields,
getting to know them is a sound investment now.",
acknowledgement = ack-nhfb,
subject = "Python (Computer program language); Go (Computer
program language); Go (Computer program language);
Python (Computer program language)",
}
@Book{Scott:2018:HDI,
author = "Corey Scott",
title = "Hands-on dependency injection in {Go}: develop clean
{Go} code that is easier to read, maintain, and test",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "338",
year = "2018",
ISBN = "1-78913-175-8",
ISBN-13 = "978-1-78913-175-8, 978-1-78913-276-2",
LCCN = "QA76.76.A65 .S368 2018; QA76.73.G63",
bibdate = "Thu Apr 22 10:11:46 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://proquest.safaribooksonline.com/?fpi=9781789132762",
abstract = "This book will take you on a journey of refactoring
existing code to adopt dependency injection using the
various methods available in Go. You will gain
knowledge of how and when to best leverage each
technique to transform code into something simple and
flexible.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Data structures
(Computer science); Application software; Development;
Development; Data structures (Computer science); Go
(Computer program language)",
tableofcontents = "Preface \\
1: Never Stop Aiming for Better \\
Technical requirements \\
Why does DI matter? \\
So, how do I define DI? \\
Code smells that indicate you might need DI \\
Code bloat \\
Resistance to change \\
Wasted effort \\
Tight coupling \\
Healthy skepticism \\
A quick word about idiomatic Go \\
Leave your baggage at the door \\
Summary \\
Questions \\
Further reading \\
2: SOLID Design Principles for Go \\
Technical requirements \\
Single responsibility principle (SRP) \\
How does this relate to DI?What does this mean for
Go?Go interfaces, structs, and functions \\
Go packages \\
Open/closed principle (OCP) \\
How does this relate to DI? \\
What does this mean for Go? \\
Liskov substitution principle (LSP) \\
How does this relate to DI? \\
What does this mean for Go? \\
Interface segregation principle (ISP) \\
How does this relate to DI? \\
What does this mean for Go? \\
Dependency inversion principle (DIP) \\
How does this relate to DI? \\
What does this mean for Go? \\
Summary \\
Questions \\
Further reading \\
3: Coding for User Experience \\
Technical requirements \\
Optimizing for humans \\
What does user experience mean for Go code? \\
Start with simple, get complicated only when you must
\\
Apply just enough abstraction \\
Follow industry, team, and language conventions \\
Export only what you must \\
Aggressively apply the single responsibility principle
\\
Discovering a good user experience \\
Who is the user? \\
What are your users capable of? \\
Why do users want to use your code? \\
How do they expect to use it? \\
When to compromise \\
Final thoughts on coding for user experience \\
A security blanket named unit tests \\
So why do I write unit tests? \\
What should I test? \\
Table-driven tests \\
StubsMocksTest-induced damage \\
Warning signs of test-induced damage \\
Parameters, config options, or outputs that only exist
because of tests \\
Parameters that cause or are caused by leaky
abstractions \\
Publishing mocks in production code \\
Excessive test coverage \\
Visualizing your package dependencies with Godepgraph
\\
Installing the tools \\
Generating a dependency graph \\
Interpreting the dependency graph \\
Summary \\
Questions \\
4: Introduction to the ACME Registration Service \\
Technical requirements \\
Goals for our system \\
High readability \\
High testability \\
Low coupling \\
Final thoughts on goals \\
Introduction to our system \\
Software architecture \\
Known issues \\
Testability \\
Duplication of effort \\
Lack of isolation in tests \\
High coupling between the data and REST packages \\
High coupling with the config package \\
Downstream currency service \\
Summary \\
Questions \\
5: Dependency Injection with Monkey Patching \\
Technical requirements \\
Monkey magic! \\
Advantages of monkey patching \\
Applying monkey patching \\
Introducing SQLMock \\
Monkey patching with SQLMock \\
Testing error handling \\
Reducing test bloat with table-driven tests \\
Monkey patching between packages \\
When the magic fades \\
Summary",
}
@Book{Spaulding:2018:GSG,
author = "Matthew Spaulding",
title = "Getting started with {Go} Programming Language",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "1 streaming video file (3 hours, 4 minutes)",
year = "2018",
ISBN = "1-78847-185-7",
ISBN-13 = "978-1-78847-185-5",
LCCN = "????",
bibdate = "Thu Apr 22 07:16:12 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Develop simple, reliable, and efficient applications
with Go language About This Video Explore fundamentals
of Go language Design and test your code with Go tools
In-depth coverage of Go libraries such as Viper and
Cobra 25 assessments specific to the course In Detail
Go is an open source programming language that makes it
easy to build simple, reliable, and efficient software.
Are you a software programmer who wants to learn go
language from scratch to build amazing applications,
then this course is for you! This course begins with
covering the basic fundamentals of golang along with
creating a basic application. You will learn data
types, control structures, loops, and object-oriented
concepts in golang. Then, you will be familiar with the
tools used for Go development and will learn to perform
testing. Also, you will learn certain standard
libraries used in golang. Moving ahead, you will be
introduced to Viper and Cobra libraries to build
Command Line applications. Finally, you will learn to
work with configuration files.",
acknowledgement = ack-nhfb,
remark = "Not recommended for use on the libraries' public
computers.",
subject = "Internet videos; Streaming video; Internet videos;
Streaming video.",
}
@Book{Andrawos:2019:HFS,
author = "Mina Andrawos",
title = "Hands-on full stack development with {Go}: build full
stack web applications with {Go}, {React}, {Gin}, and
{GopherJS}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "v + 311",
year = "2019",
ISBN = "1-78913-865-5",
ISBN-13 = "978-1-78913-075-1, 978-1-78913-865-8",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 09:57:22 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://proquest.safaribooksonline.com/?fpi=9781789130751",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Web applications;
Application software; Development; Development; Go
(Computer program language); Web applications.",
tableofcontents = "1. The Go language. Welcome to full stack Go \\
Building blocks of the Go language \\
Go concurrency \\
2. The frontend. Frontend with React.js \\
Building a frontend for GoMusic \\
3. Web APIs and middleware in Go \\
RESTful web APIs in Go with the Gin framework \\
Advanced web Go applications with Gin and React
technical requirements \\
Testing and benchmarking your web API \\
Introduction to Isomorphic Go with GopherJS \\
Where to go from here?",
}
@Book{Ball:2019:WCG,
author = "Thorsten Ball",
title = "Writing a compiler in {Go}",
publisher = "Thorsten Ball",
address = "Aschaffenburg, Germany",
edition = "Version 1.1.",
pages = "351",
year = "2019",
ISBN = "3-9820161-0-X",
ISBN-13 = "978-3-9820161-0-8",
LCCN = "QA76.73.G63 B348 2019",
bibdate = "Mon Sep 20 07:28:07 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/master.bib",
abstract = "This is the sequel to \booktitle{Writing An
Interpreter In Go}. We're picking up right where we
left off and write a compiler and a virtual machine for
Monkey. Runnable and tested code front and center,
built from the ground up, step by step --- just like
before. But this time, we're going to define bytecode,
compile Monkey and execute it in our very own virtual
machine. It's the next step in Monkey's evolution.",
acknowledgement = ack-nhfb,
shorttableofcontents = "Compilers and virtual machines \\
Hello bytecode! \\
Compiling expressions \\
Conditionals \\
Keeping track of names \\
String, array and hash \\
Functions \\
Built-in functions \\
Closures \\
Taking time",
subject = "Go (Computer program language); Compilers (Computer
programs); Computer programming; Compilers (Computer
programs); Computer programming; Go (Computer program
language)",
tableofcontents = "Acknowledgments / 5 \\
Introduction / 6 \\
Evolving Monkey / 7 \\
The Past and Present / 7 \\
The Future / 11 \\
Use This Book / 11 \\
1 Compilers \& Virtual Machines / 13 \\
Compilers / 14 \\
Virtual and Real Machines / 18 \\
Real Machines / 19 \\
What Is a Virtual Machine? / 25 \\
Why Build One? / 28 \\
Bytecode / 30 \\
What We're Going to Do, or: the Duality of VM and
Compiler / 33 \\
2 Hello Bytecode! / 34 \\
First Instructions / 35 \\
Starting With Bytes / 36 \\
The Smallest Compiler / 42 \\
Bytecode, Disassemble! / 48 \\
Back to the Task at Hand / 53 \\
Powering On the Machine / 56 \\
Adding on the Stack / 64 \\
Hooking up the REPL / 70 \\
3 Compiling Expressions / 73 \\
Cleaning Up the Stack / 73 \\
Infix Expressions / 78 \\
Booleans / 83 \\
Comparison Operators / 88 \\
Prefix Expressions / 96 \\
4 Conditionals / 103 \\
Jumps / 106 \\
Compiling Conditionals / 109 \\
Executing Jumps / 125 \\
Welcome Back, Null! / 129 \\
5 Keeping Track of Names / 138 \\
The Plan / 139 \\
Compiling Bindings / 141 \\
Introducing: the Symbol Table / 144 \\
Using Symbols in the Compiler / 147 \\
Adding Globals to the VM / 150 \\
6 String, Array and Hash / 156 \\
String / 157 \\
Array / 162 \\
Hash / 168 \\
Adding the index operator / 175 \\
7 Functions / 182 \\
Dipping Our Toes: a Simple Function / 182 \\
Representing Functions / 183 \\
Opcodes to Execute Functions / 184 \\
Compiling Function Literals / 188 \\
Compiling Function Calls / 204 \\
Functions in the VM / 207 \\
A Little Bonus / 219 \\
Local Bindings / 220 \\
Opcodes for Local Bindings / 221 \\
Compiling Locals / 225 \\
Implementing Local Bindings in the VM / 239 \\
Arguments / 249 \\
Compiling Calls With Arguments / 250 \\
Resolving References to Arguments / 256 \\
Arguments in the VM / 259 \\
8 Built-in Functions / 269 \\
Making the Change Easy / 270 \\
Making the Change: the Plan / 277 \\
A New Scope for Built-in Functions / 277 \\
Executing built-in functions / 283 \\
9 Closures / 290 \\
The Problem / 291 \\
The Plan / 292 \\
Everything's a closure / 294 \\
Compiling and resolving free variables / 307 \\
Creating real closures at run time / 320 \\
Recursive Closures / 325 \\
10 Taking Time / 341 \\
Resources / 345 \\
Feedback / 348 \\
Changelog /349",
}
@Book{Guerrieri:2019:HSP,
author = "Alex Guerrieri",
title = "Hands-on system programming with {Go}: build modern
and concurrent applications for {Unix} and {Linux}
systems using {Golang}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "xii + 437",
year = "2019",
ISBN = "1-78980-336-5 (e-book), 1-78980-407-8",
ISBN-13 = "978-1-78980-336-5 (e-book), 978-1-78980-407-2",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 07:34:05 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/linux.bib;
https://www.math.utah.edu/pub/tex/bib/unix.bib",
URL = "http://proquest.safaribooksonline.com/?fpi=9781789804072",
abstract = "Go is the new systems programming language for Linux
and Unix systems. After a brief introduction of
Unix-based OS and of system programming, we'll dive
into Go standard packages, focusing on how easily they
allow to interact will all the functionality of the OS.
By the end of this book, you will be comfortable with
systems programming using Go.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Application software;
Development; Development; Go (Computer program
language)",
tableofcontents = "Preface \\
Section 1: An Introduction to System Programming and Go
\\
1: An Introduction to System Programming \\
Technical requirements \\
Beginning with system programming \\
Software for software \\
Languages and system evolution \\
System programming and software engineering \\
Application programming interfaces \\
Types of APIs \\
Operating systems \\
Libraries and frameworks \\
Remote APIs \\
Web APIs \\
Understanding the protection ring \\
Architectural differences \\
Kernel space and user space \\
Diving into system calls \\
Services provided \\
Process control \\
File management \\
Device management \\
Information maintenance \\
Communication \\
The difference between operating systems \\
Understanding the POSIX standard \\
POSIX standards and features \\
POSIX. 1 \\
core services \\
POSIX. 1b and POSIX. 1c \\
real-time and thread extensions \\
POSIX. 2 \\
shell and utilities \\
OS adherence \\
Linux and macOS \\
Windows \\
Summary \\
Questions \\
2: Unix OS Components \\
Technical requirements \\
Memory management \\
Techniques of management \\
Virtual memory \\
Understanding files and filesystems \\
Operating systems and filesystems \\
Linux \\
macOS \\
Windows \\
Files and hard and soft links \\
Unix filesystem \\
Root and inodes \\
Directory structure \\
Navigation and interaction \\
Mounting and unmounting \\
Processes \\
Process properties \\
Process life cycle \\
Foreground and background \\
Killing a job \\
Users, groups, and permissions \\
Users and groups \\
Owner, group, and others \\
Read, write, and execute \\
Changing permission \\
Process communications \\
Exit codes \\
Signals \\
Pipes \\
Sockets \\
Summary \\
Questions \\
3: An Overview of Go \\
Technical requirements \\
Language features \\
History of Go \\
Strengths and weaknesses \\
Namespace \\
Imports and exporting symbols \\
Type system \\
Basic types \\
Composite types \\
Custom-defined types \\
Variables and functions \\
Handling variables \\
Declaration \\
Operations \\
Casting \\
Scope \\
Constants \\
Functions and methods \\
Values and pointers \\
Understanding flow control \\
Condition \\
Looping \\
Exploring built-in functions \\
Defer, panic, and recover \\
Concurrency model \\
Understanding channels and goroutines \\
Understanding memory management \\
Stack and heap \\
The history of GC in Go \\
Building and compiling programs \\
Install \\
Build \\
Run \\
Summary \\
Questions \\
Section 2: Advanced File I/O Operations \\
4: Working with the Filesystem \\
Technical requirements \\
Handling paths \\
Working directory \\
Getting and setting the working directory \\
Path manipulation \\
Reading from files \\
Reader interface \\
The file structure \\
Using buffers \\
Peeking content \\
Closer and seeker \\
Writing to file \\
Writer interface \\
Buffers and format \\
Efficient writing \\
File modes \\
Other operations \\
Create \\
Truncate \\
Delete \\
Move \\
Copy \\
Stats \\
Changing properties \\
Third-party packages \\
Virtual filesystems \\
Filesystem events \\
Summary \\
Questions \\
5: Handling Streams \\
6: Building pseudo-terminals \\
7: Handling processes and daemons \\
8: Exit codes, signals, and pipes \\
9: Network programming \\
10:Data encoding using Go \\
11: Dealing with channels and Goroutines \\
12: Synchronization with sync and atomic \\
13: Coordination using context \\
14: Implementing concurrency patterns \\
15: Using reflection \\
16: Using CGO",
}
@Book{McGavren:2019:HFG,
author = "Jay McGavren",
title = "Head First {Go}: a brain-friendly guide",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "xxxiv + 520",
year = "2019",
ISBN = "1-4919-6955-5",
ISBN-13 = "978-1-4919-6955-7",
LCCN = "QA76.73.G63 M34 2019",
bibdate = "Thu Apr 22 07:23:50 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Go represents an attempt to improve on some weaknesses
of traditional compiled programming languages. It
de-emphasizes or removes error-prone language
structures like class inheritance and exception
handling. It features great concurrency support and
automatic memory management (garbage
collection).Existing Go books tend to be highly
technical in nature, teaching all aspects of the
language regardless of their relevance to beginners.
This book, rather than talking about the features of Go
in abstract terms, features simple, clear examples that
demonstrate Go in action, and diagrams to explain
difficult concepts.This book will not only teach
developers basic language features, it will get them
comfortable consulting error output, documentation, and
search engines to find solutions to problems. It will
teach all the conventions and techniques that employers
expect an entry-level Go developer to know.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Computer programming;
Application software; Development; COMPUTERS /
Programming / General; Development; Computer
programming; Go (Computer program language)",
tableofcontents = "Let's get going: syntax basics \\
Which code runs next?: conditionals and loops \\
Call me: functions \\
Bundles of code: packages \\
On the list: arrays \\
Appending issue: slices \\
Labeling data: maps \\
Building storage: structs \\
You're my type: defined type \\
Keep it to yourself: encapsulation and embedding \\
What can you do?: interfaces \\
Back on your feet: recovering from failure \\
Sharing work: goroutines and channels \\
Code quality assurance: automated testing \\
Responding to requests: web apps \\
A pattern to follow: HTML templates \\
Understanding os. OpenFile: opening files \\
Six things we didn't cover: leftovers",
}
@Book{McNerney:2019:BBB,
author = "P. J. McNerney",
title = "Beginning {Bazel}: Building and Testing for {Java},
{Go}, and More",
publisher = pub-APRESS,
address = pub-APRESS:adr,
pages = "xi + 192",
year = "2019",
ISBN = "1-4842-5194-6",
ISBN-13 = "978-1-4842-5193-5, 978-1-4842-5194-2",
LCCN = "QA75.5-76.95",
bibdate = "Thu Apr 22 10:09:52 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/java2010.bib",
URL = "http://www.vlebooks.com/vleweb/product/openreader?id=none\%26isbn=9781484251942",
abstract = "Discover Bazel, a new build and software test set of
tools for today's programmers and developers. This book
shows you how to speed up your builds and tests, and
how to use Bazel in the context of your favorite
programming language. You'll see that the languages and
SDKs supported include Java, Android, iOS, and Go. What
You Will Learn Use Bazel as a build tool Test software
with Bazel Work with Java, C++, Android, iOS, Go, and
other programming languages Run Bazel on Linux, macOS,
and Windows Scale and extend Bazel to other languages
and platforms Who This Book Is For Experienced
programmers looking for alternative build/test tools.",
acknowledgement = ack-nhfb,
remark = "Referencing Build Targets Outside of the Current
Package.",
subject = "Computer software; Development; Testing",
tableofcontents = "About the Author \\
About the Technical Reviewer \\
1: Introduction \\
What This Book Is \\
What This Book Is Not \\
Features of Bazel \\
High-Level Build Language \\
Explicit Dependency Management \\
Advanced Visibility Features \\
Explicit Workspace Management \\
Remote Build Execution and Caching \\
Build Dependency Analysis \\
Fast, Correct Builds (and Tests) \\
Who This Book Is For (and Possibly Not For) \\
2: Setup and Installation \\
MacOS \\
Installing Xcode \\
Installing Bazel \\
Installing Java \\
Verifying Your Python Version \\
Ubuntu Linux \\
Installing Required Packages \\
Installing Bazel \\
Installing Java \\
Windows \\
Setting Up Your System \\
Installing Required Applications \\
Visual C++ Redistributable for Visual Studio 2015 \\
MSYS2 \\
Bazel Installation \\
Installing Language Support \\
C++ \\
Java \\
Python \\
Final Word \\
3: Your First Bazel Project \\
Setting Up Your Workspace \\
Adding Source Code \\
Hello World, Java Style \\
Specifying the BUILD Targets \\
Building Your Targets \\
Build the Binary \\
Running the Binary \\
Creating and Using Dependencies \\
Adding IntMultiplier.java to java\_binary \\
Creating a java\_library Dependency \\
Depending on Build Targets \\
Testing Your Build Targets \\
Setting Up Testing Dependencies \\
Creating the java\_test Build Target \\
Build (and Clean) the World \\
Build Everything (In a Directory) \\
Build Everything (At This Directory and Below) \\
Clean (Mostly) Everything \\
Final Word \\
4: WORKSPACE File Functionality \\
WORKSPACE Files \\
Adding New Rules to WORKSPACE \\
A Deeper Dive into the Load Path \\
Finding the bazel\_tools Repository \\
Loading Multiple Rules at the Same Time \\
Referencing Other Dependencies \\
http\_archive \\
git\_repository \\
Retrieving a Git Repository \\
Fine Print on git\_repository \\
http\_archive vs. git\_repository \\
Employing a New Language \\
Locating the Go Language Rules Repository \\
5: A Simple Echo Client/Server Program \\
Setting Up Your Workspace \\
Go Echo Server \\
Java Echo Client \\
Naming the Echo Client and Server \\
Echoing Between Programs \\
Upgrading to JSON \\
JSON in Go \\
JSON in Java \\
GSON Setup \\
Adding the Transmission Object to EchoClient \\
Executing the Echo Client/Server with JSONFinal Word:
Duplication of Effort \\
6: Protocol Buffers and Bazel \\
Setting Up Your Workspace \\
Creating Your First Protocol Buffer \\
Using the Protocol Buffer in Java \\
Creating the Java Proto Library Target \\
Using Your Java Protocol Buffer Target \\
Using the Protocol Buffer in Go \\
Creating the Go Proto Library Target \\
Using Your Go Protocol Buffer Target \\
Echo Using Protocol Buffers \\
Dependency Tracking and Management \\
Change Management in Action \\
Final Word \\
7: Code Organization and Bazel \\
Setup \\
Separating the Protocol Buffers",
}
@Book{Torres:2019:ASG,
author = "Aaron Torres",
title = "Advanced solutions in {Go} testing and distributed
systems",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "1 streaming video file (1 hour, 48 minutes)",
year = "2019",
ISBN = "1-78862-788-1",
ISBN-13 = "978-1-78862-788-7",
LCCN = "????",
bibdate = "Thu Apr 22 10:31:22 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "``Go (a.k.a. Golang) is a statically-typed programming
language first developed at Google. It is derived from
C with additional features such as garbage collection,
type safety, dynamic-typing capabilities, additional
built-in types, and a large standard library. This
video takes off where basic tutorials on the language
leave off. You can immediately put into practice some
of the more advanced concepts and libraries offered by
the language while avoiding some of the common mistakes
for new Go developers. The video explores applications
that interact with users, such as websites,
command-line tools, or via the file system. It
demonstrates how to handle advanced topics such as
parallelism, distributed systems, and performance
tuning. Lastly, it finishes with reactive and
serverless programming in Go.''--Resource description
page.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Application software;
Development; Electronic videos; local",
}
@InProceedings{Ciolino:2020:GTN,
author = "Matthew Ciolino and Josh Kalin and David Noever",
editor = "{IEEE}",
booktitle = "2020 Third International Conference on Artificial
Intelligence for Industries {(AI4I)}",
title = "The {Go} Transformer: Natural Language Modeling for
Game Play",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "23--26",
year = "2020",
DOI = "https://doi.org/10.1109/AI4I49448.2020.00012",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
}
@Book{Steele:2020:BGG,
author = "Tom Steele and Chris Patten and Dan Kottmann",
title = "{Black Hat Go}: {Go} Programming for Hackers and
Pentesters",
publisher = pub-NO-STARCH,
address = pub-NO-STARCH:adr,
pages = "xxv + 337",
year = "2020",
ISBN = "1-0981-2264-X, 1-59327-865-9",
ISBN-13 = "978-1-0981-2264-5, 978-1-59327-865-6",
LCCN = "QA76.9.A25 S739 2020",
bibdate = "Thu Apr 22 07:27:53 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Black Hat Go explores the darker side of Go, the
popular programming language revered by hackers for its
simplicity, efficiency, and reliability. It provides an
arsenal of practical tactics from the perspective of
security practitioners and hackers to help you test
your systems, build and automate tools to fit your
needs, and improve your offensive security skillset,
all using the power of Go. You'll begin your journey
with a basic overview of Go's syntax and philosophy and
then start to explore examples that you can leverage
for tool development, including common network
protocols like HTTP, DNS, and SMB. You'll then dig into
various tactics and problems that penetration testers
encounter, addressing things like data pilfering,
packet sniffing, and exploit development. You'll create
dynamic, pluggable tools before diving into
cryptography, attacking Microsoft Windows, and
implementing steganography. You'll learn how to: * Make
performant tools that can be used for your own security
projects. * Create usable tools that interact with
remote APIs. * Scrape arbitrary HTML data. * Use Go's
standard package, net/http, for building HTTP servers.
* Write your own DNS server and proxy. Use DNS
tunneling to establish a C2 channel out of a
restrictive network. * Create a vulnerability fuzzer to
discover an application's security weaknesses. * Use
plug-ins and extensions to future-proof products. * Use
plug-ins and extensions to future-proof products. *
Build an RC2 symmetric-key brute-forcer. * Implant data
within a Portable Network Graphics (PNG) image Are you
ready to add to your arsenal of security tools? Then
let's Go!",
acknowledgement = ack-nhfb,
}
@Book{Strecansky:2020:HHP,
author = "Bob Strecansky",
title = "Hands-on High Performance with {Go}: Boost and
Optimize the Performance of Your {Golang} Applications
at Scale with Resilience",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "vii + 391",
year = "2020",
ISBN = "1-78980-177-X (paperback), 1-78980-578-3",
ISBN-13 = "978-1-78980-177-4 (paperback), 978-1-78980-578-9",
LCCN = "QA76.73.G63",
bibdate = "Thu Apr 22 07:32:11 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "http://proquest.safaribooksonline.com/?fpi=9781789805789",
abstract = "Hands-On High Performance with Go is a complete
resource with proven methodologies and techniques to
help you diagnose and fix performance problems in your
Go applications. With this book, you will be confident
enough to solve the performance-related concerns in
your enterprise applications.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Application software;
Development; Development; Go (Computer program
language)",
tableofcontents = "Cover \\
Title Page \\
Copyright and Credits \\
Dedication \\
About Packt \\
Contributors \\
Table of Contents \\
Preface \\
Section 1: Learning about Performance in Go \\
1: Introduction to Performance in Go \\
Technical requirements \\
Understanding performance in computer science \\
A brief note on Big O notation \\
Methods to gauge long term performance \\
Optimization strategies overview \\
Optimization levels \\
A brief history of Go \\
The Go standard library \\
Go toolset \\
Benchmarking overview \\
The ideology behind Go performance \\
Goroutines \\
performance from the start \\
Channels \\
a typed conduit \\
C-comparable performance \\
Large-scale distributed systems \\
Summary \\
2: Data Structures and Algorithms \\
Understanding benchmarking \\
Benchmark execution \\
Real-world benchmarking \\
Introducing Big O notation \\
Practical Big O notation example \\
Data structure operations and time complexity \\
O(1) \\
constant time \\
O(log n) \\
logarithmic time \\
O(n) \\
linear time \\
O(n log n) \\
quasilinear time \\
O(n2) \\
quadratic time \\
O(2n) \\
exponential time \\
Understanding sort algorithms \\
Insertion sort \\
Heap sort \\
Merge sort \\
Quick sort \\
Understanding search algorithms \\
Linear search \\
Binary search \\
Exploring trees \\
Binary trees \\
Doubly linked list \\
Exploring queues \\
Common queuing functions \\
Common queuing patterns \\
Summary \\
3: Understanding Concurrency \\
Understanding closures \\
Anonymous functions \\
Anonymous functions with respect to closures \\
Closures for nesting and deferring work \\
HTTP handlers with closures \\
Exploring goroutines \\
The Go scheduler \\
Go scheduler goroutine internals \\
The M struct \\
The P struct \\
The G struct \\
Goroutines in action \\
Introducing channels \\
Channel internals \\
Buffered channels \\
Ranges over channels \\
Unbuffered channels \\
Selects \\
Introducing semaphores \\
Understanding WaitGroups \\
Iterators and the process of iteration \\
Briefing on generators \\
Summary \\
4: STL Algorithm Equivalents in Go \\
Understanding algorithms in the STL \\
Sort \\
Reverse \\
Min element and max element \\
Binary search \\
Understanding containers \\
Sequence containers \\
Array \\
Vector \\
Deque \\
List \\
Forward list \\
Container adapters \\
Queue \\
Priority queue \\
Stack \\
Associative containers \\
Set \\
Multiset \\
MapMultimap \\
Understanding function objects \\
Functors \\
Iterators \\
Internal iterators \\
External iterators \\
Generators \\
Implicit Iterators \\
Summary \\
5: Matrix and Vector Computation in Go \\
Introducing Gonum and the Sparse library \\
Introducing BLAS \\
Introducing vectors \\
Vector computations \\
Introducing matrices \\
Matrix operations \\
Matrix addition \\
A practical example (matrix subtraction) \\
Scalar multiplication \\
Scalar multiplication practical example \\
Matrix multiplication \\
Matrix multiplication practical example \\
Matrix transposition",
}
@Book{Bodner:2021:LGI,
author = "Jon Bodner",
title = "Learning {Go}: an Idiomatic Approach to Real-world
{Go} Programming",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "xvii + 352",
year = "2021",
ISBN = "1-4920-7721-6",
ISBN-13 = "978-1-4920-7721-3",
LCCN = "QA76.73.G63 B64 2021",
bibdate = "Thu Apr 22 07:19:32 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/ora.bib",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Computer programming;
Web applications; Programming; Open source software; Go
(Computer program language)",
}
@Article{Lemire:2021:NPG,
author = "Daniel Lemire",
title = "Number parsing at a gigabyte per second",
journal = j-SPE,
volume = "51",
number = "8",
pages = "1700--1727",
month = aug,
year = "2021",
CODEN = "SPEXBL",
DOI = "https://doi.org/10.1002/spe.2984",
ISSN = "0038-0644 (print), 1097-024X (electronic)",
ISSN-L = "0038-0644",
bibdate = "Fri Jul 23 09:04:36 MDT 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/fparith.bib;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/spe.bib",
abstract = "With disks and networks providing gigabytes per
second, parsing decimal numbers from strings becomes a
bottleneck. We consider the problem of parsing decimal
numbers to the nearest binary floating-point value. The
general problem requires variable-precision arithmetic.
However, we need at most 17 digits to represent 64-bit
standard floating-point numbers (IEEE 754). Thus, we
can represent the decimal significand with a single
64-bit word. By combining the significand and
precomputed tables, we can compute the nearest
floating-point number using as few as one or two 64-bit
multiplications. Our implementation can be several
times faster than conventional functions present in
standard C libraries on modern 64-bit systems (Intel,
AMD, ARM, and POWER9). Our work is available as open
source software used by major systems such as Apache
Arrow and Yandex ClickHouse. The Go standard library
has adopted a version of our approach.",
acknowledgement = ack-nhfb,
ajournal = "Softw. Pract. Exp.",
fjournal = "Software --- Practice and Experience",
journal-URL = "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
onlinedate = "11 May 2021",
}
@Article{Nelson:2021:GAT,
author = "Grant Nelson and Clemente Izurieta",
title = "A Gap in the Analysis of Technical Debt in Procedural
Languages: an Experiential Report on {Go}",
journal = j-IEEE-SOFTWARE,
volume = "38",
number = "6",
pages = "71--75",
year = "2021",
CODEN = "IESOEG",
DOI = "https://doi.org/10.1109/MS.2021.3103710",
ISSN = "0740-7459 (print), 1937-4194 (electronic)",
ISSN-L = "0740-7459",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
fjournal = "IEEE Software",
journal-URL = "https://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=52",
}
@Book{Thornton:2021:GBG,
author = "Edward Thornton",
title = "{Go} for Beginners: A Genius Guide to {Go}
Programming",
publisher = "????",
address = "????",
pages = "????",
year = "2021",
ISBN = "????",
ISBN-13 = "979-85-399-6273-9",
LCCN = "????",
bibdate = "Mon Sep 20 07:41:30 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
}
@Book{Titmus:2021:CNG,
author = "Matthew Titmus",
title = "Cloud Native {Go}: building reliable services in
unreliable environments",
publisher = pub-ORA-MEDIA,
address = pub-ORA-MEDIA:adr,
pages = "????",
year = "2021",
ISBN = "1-4920-7633-3",
ISBN-13 = "978-1-4920-7633-9",
LCCN = "????",
bibdate = "Thu Apr 22 07:21:07 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/ora.bib",
acknowledgement = ack-nhfb,
subject = "Cloud computing; Go (Computer program language); Cloud
computing; Go (Computer program language)",
}
@Book{Williams:2021:BCP,
author = "Andrew Williams",
title = "Building Cross-Platform {GUI} Applications with
{Fyne}: Create beautiful, platform-agnostic graphical
applications using {Fyne} and the {Go} programming
language",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "xii + 301",
year = "2021",
ISBN = "1-80056-316-7 (paperback), 1-80056-688-3 (PDF
e-book)",
ISBN-13 = "978-1-80056-316-2 (paperback), 978-1-80056-688-0 (PDF
e-book)",
LCCN = "QA76.9.U83 .W555 2021",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Understand how to use the Fyne toolkit to build
exciting apps for a range of devices and deploy them
effectively. Key Features: Learn how to use standard
widgets, dialogs, and layouts as well as how to build
your own Understand how to develop an app and package
and distribute it to different operating systems and
app stores. Explore the design principles and vision of
the Fyne toolkit and how that may align with your
project. Book Description: The history of graphical
application development is long and complicated, with
various development challenges that persist to this
day. The mix of technologies involved and the need to
use different programming languages led to a very steep
learning curve for developers looking to build
applications across multiple platforms. In Building
Cross-Platform GUI Applications with Fyne, you'll
understand how the Go language, when paired with a
modern graphical toolkit such as Fyne, can overcome
these issues and make application development much
easier. To provide an easy-to-use framework for
cross-platform app development, the Fyne project offers
many graphical concepts and design principles that are
outlined throughout this book. By working through five
example projects, you'll learn how to build apps
effectively, focusing on each of the main areas,
including the canvas, layouts, file handling, widgets,
data binding, and themes. The book will also show you
how the completed applications can then be run on your
desktop computer, laptop, and smartphone. After
completing these projects, you will discover how to
prepare applications for release and distribute them to
platform marketplaces and app stores. By the end of
this book, you'll be able to create cross-platform
graphical applications with visually appealing user
interfaces and concise code. What you will learn:
Become well-versed with the history of GUI development
and how Fyne and the Golang programming language make
it easier. Explore how the Fyne toolkit is architected
and the various modules are provided. Discover how Fyne
apps can be tested and constructed using best
practices. Construct five complete applications and
deploy them to your devices. Customize the design of
your apps by extending widgets and themes. Understand
the separation and presentation of data and how to test
and build applications that present dynamic data. Who
this book is for: This Fyne-Golang GUI book is for
developers from any background who are looking to build
cross-platform applications \ldots{}",
acknowledgement = ack-nhfb,
tableofcontents = "A Brief History of GUI Toolkits and Cross-Platform
Development \\
The Future According to Fyne \\
Window, Canvas, and Drawing \\
Layout and File handling \\
Widget Library and Themes \\
Data Binding and Storage \\
Building Custom Widgets and Themes \\
Project Structure and Best Practices \\
Bundling Resources and Preparing for Release
Distribution \\
App Stores and Beyond \\
Appendix A: Developer Tool Installation \\
Appendix B: Installation of Mobile Build Tools \\
Appendix C: Cross-Compiling",
}
@Book{Woodbeck:2021:NPG,
author = "Adam Woodbeck",
title = "Network Programming with {Go}: Code Secure and
Reliable Network Services from Scratch",
publisher = pub-NO-STARCH,
address = pub-NO-STARCH:adr,
pages = "xxii + 363",
year = "2021",
ISBN = "1-0981-2889-3, 1-71850-088-2 (paperback)",
ISBN-13 = "978-1-0981-2889-0, 978-1-71850-088-4 (paperback)",
LCCN = "QA76.73.G63 W663 2021",
bibdate = "Thu Apr 22 07:25:26 MDT 2021",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Go combines the best parts of many other programming
languages. It's fast, scalable, and designed for
high-performance networking and multiprocessing-in
other words, it's perfect for network programming.
Network Programming with Go is for developers ready to
start leveraging Go's ease of use for writing secure,
readable, production-ready network code. Early chapters
establish a foundation of networking and
traffic-routing know-how upon which the rest of the
book builds. You'll put that knowledge to use as author
Adam Woodbeck guides you through writing programs that
communicate using TCP, UDP, Unix sockets, and other
features that ensure reliable data transmission. As you
progress, you'll explore higher-level network protocols
like HTTP and HTTP/2, then build applications that
securely interact with servers, clients, and APIs over
a network using TLS. In addition, Woodbeck shows you
how to create a simple messaging protocol, develop
tools for monitoring network traffic, craft a custom
web server, and implement best practices for
interacting with cloud providers using their SDKs.
Along the way, you'll learn: * IP basics for writing
effective network programs, such as IPv4 and IPv6
multicasting, ports, and network address translation. *
How to use handlers, middleware, and multiplexers to
build capable HTTP-based applications with minimal
code. * The OSI and TCP/IP models for layered data
architectures. * Methods for reading data from/writing
data to a network connection, like the
type-length-value encoding scheme. * Tools for
incorporating authentication and encryption into your
applications using TLS, like mutual authentication. *
How to serialize data for storage or transmission in
Go-friendly formats like JSON, Gob, XML, and protocol
buffers. * How to Leverage Go's code generation support
to efficiently communicate with gRPC-based network
services So get ready to take advantage of Go's
built-in concurrency, rapid compiling, and rich
standard library. Because when it comes to writing
robust network programs, it's Go time.",
acknowledgement = ack-nhfb,
}
@Book{Yoon:2021:AGB,
author = "Harry Yoon",
title = "The Art of {Go} --- Basics: Introducing to Programming
in {Go}",
publisher = "Coding Books Press",
address = "????",
pages = "????",
year = "2021",
ISBN-13 = "979-87-11-30861-4",
LCCN = "????",
bibdate = "Mon Sep 20 07:38:53 2021",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
}
@Article{Costa:2022:BTS,
author = "Diego Elias Costa and Suhaib Mujahid and Rabe
Abdalkareem and Emad Shihab",
title = "Breaking Type Safety in {Go}: An Empirical Study on
the Usage of the {\tt unsafe} Package",
journal = j-IEEE-TRANS-SOFTW-ENG,
volume = "48",
number = "7",
pages = "2277--2294",
month = jul,
year = "2022",
CODEN = "IESEDJ",
DOI = "https://doi.org/10.1109/TSE.2021.3057720",
ISSN = "0098-5589 (print), 1939-3520 (electronic)",
ISSN-L = "0098-5589",
bibdate = "Thu Jul 21 10:20:56 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2020.bib",
acknowledgement = ack-nhfb,
fjournal = "IEEE Transactions on Software Engineering",
journal-URL = "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}
@Article{Cox:2022:GPL,
author = "Russ Cox and Robert Griesemer and Rob Pike and Ian
Lance Taylor and Ken Thompson",
title = "The {Go} programming language and environment",
journal = j-CACM,
volume = "65",
number = "5",
pages = "70--78",
month = may,
year = "2022",
CODEN = "CACMA2",
DOI = "https://doi.org/10.1145/3488716",
ISSN = "0001-0782 (print), 1557-7317 (electronic)",
ISSN-L = "0001-0782",
bibdate = "Tue Apr 26 07:08:57 MDT 2022",
bibsource = "https://www.math.utah.edu/pub/tex/bib/cacm2020.bib;
https://www.math.utah.edu/pub/tex/bib/go.bib",
URL = "https://dl.acm.org/doi/10.1145/3488716",
abstract = "Released as open source in November 2009, Go has
become the foundation for critical infrastructure at
every major cloud provider. Its creators look back on
how Go got here and why it has stuck around.",
acknowledgement = ack-nhfb,
fjournal = "Communications of the ACM",
journal-URL = "https://dl.acm.org/loi/cacm",
}
@Book{Doak:2022:GDL,
author = "John Doak and David Justice",
title = "{Go} for {DevOps}: Learn how to use the {Go} language
to automate servers, the cloud, {Kubernetes}, {GitHub},
{Packer}, and {Terraform}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "xxiv + 608",
year = "2022",
ISBN = "1-80181-889-4 (paperback), 1-80181-934-3 (e-book)",
ISBN-13 = "978-1-80181-889-6 (paperback), 978-1-80181-934-3
(e-book)",
LCCN = "QA76.73.G63 D63 2022",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
abstract = "Achieve reliable release automation and get zero
troublesome notifications on your release day. Key
Features:: Develop the skills to build command-line
tools to control thousands of nodes. Use Go to create
Terraform providers and GitHub actions and extend
Kubernetes. Gain the knowledge to build DevOps
workflows that are understandable, scalable, and safe.
Book Description: Go is the go-to language for DevOps
libraries and services, and without it, achieving fast
and safe automation is a challenge. With the help of Go
for DevOps, you'll learn how to deliver services with
ease and safety, becoming a better DevOps engineer in
the process. Some of the key things this book will
teach you are how to write Go software to automate
configuration management, update remote machines,
author custom automation in GitHub Actions, and
interact with Kubernetes. As you advance through the
chapters, you'll explore how to automate the cloud
using software development kits (SDKs), extend
HashiCorp's Terraform and Packer using Go, develop your
own DevOps services with gRPC and REST, design system
agents, and build robust workflow systems. By the end
of this Go for DevOps book, you'll understand how to
apply development principles to automate operations and
provide operational insights using Go, which will allow
you to react quickly to resolve system failures before
your customers realize something has gone wrong. What
you will learn Understand the basic structure of the Go
language to begin your DevOps journey Interact with
filesystems to read or stream data Communicate with
remote services via REST and gRPC Explore writing tools
that can be used in the DevOps environment Develop
command-line operational software in Go. Work with
popular frameworks to deploy production software.
Create GitHub actions that streamline your CI/CD
process. Write a ChatOps application with Slack to
simplify production visibility. Who this book is for:
This book is for Ops and DevOps engineers who would
like to use Go to develop their own DevOps tooling or
integrate custom features with DevOps tools such as
Kubernetes, GitHub Actions, HashiCorp Packer, and
Terraform. Experience with some type of programming
language, but not necessarily Go, is necessary to get
started with this book.",
acknowledgement = ack-nhfb,
tableofcontents = "Section 1: Getting Up and Running with Go \\
1: Go Language Basics \\
2: Go Language Essentials \\
3: Setting Up Your Environment \\
4: Filesystem Interactions \\
5: Using Common Data Formats \\
6: Interacting with Remote Data Sources \\
7: Writing Command-Line Tooling \\
8: Automating Command-Line Tasks \\
Section 2: Instrumenting, Observing, and Responding \\
9: Observability with OpenTelemetry \\
10: Automating Workflows with GitHub Actions \\
11: Using ChatOps to Increase Efficiency \\
Section 3: Cloud ready Go \\
12: Creating Immutable Infrastructure Using Packer \\
13: Infrastructure as Code with Terraform \\
14: Deploying and Building Applications in Kubernetes
\\
15: Programming the Cloud \\
16: Designing for Chaos",
}
@Book{Feigenbaum:2022:GJP,
author = "Barry Feigenbaum",
title = "{Go} for {Java} Programmers Learn the {Google Go}
Programming Language",
publisher = pub-APRESS,
address = pub-APRESS:adr,
pages = "xxxv + 582 + 61 + 1",
year = "2022",
DOI = "https://doi.org/10.1007/978-1-4842-7199-5",
ISBN = "1-4842-7199-8",
ISBN-13 = "978-1-4842-7199-5",
LCCN = "QA76.73.G63 F45 2022",
bibdate = "Wed Feb 16 12:54:41 MST 2022",
bibsource = "fsz3950.oclc.org:210/WorldCat;
https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/java2020.bib",
abstract = "Get an in-depth introduction to the Go programming
language and its associated standard runtime libraries.
This book is targeted towards programmers that already
know the Java programming language and uses that Java
knowledge to direct the learning of Go. You will get a
deep understanding of the Go language and obtain a good
introduction to the extensive Go standard libraries.
This book teaches Go through clear descriptions of Go
features, contrasting them with similar Java features
and via providing extensive code examples. After
reading this book you will be knowledgeable enough
about Go and its libraries to begin doing effective
programming using the Go language. Go for Java
Programmers is structured more like a tutorial than a
reference document. It covers key features of Go, but
not every little detail as a reference might. Its goal
is to get you competent enough in Go and its runtime
that you can begin to effectively write Go programs.
What You Will Learn Examine the key Go Runtime
libraries and how they compare to Java libraries See
when it is appropriate to use the Go language instead
of the Java language Read and understand programs
written in Go Write many programs in Go Determine when
Go is an appropriate language to develop applications
in Discover how the Go and Java languages and
development experience compare and contrast Who This
Book Is For Primarily existing professional Java
programmers or students that already know something
about Java. A basic understanding of Java is expected.
Some basic programming experience with imperative
languages is expected.",
acknowledgement = ack-nhfb,
subject = "Go (Computer program language); Java (Computer program
language)",
tableofcontents = "Intro \\
Table of Contents \\
About the Author \\
About the Technical Reviewer \\
Acknowledgments \\
Introduction \\
Assessments \\
Part I: First Look at Go \\
1: A Brief Look at Go vs. Java \\
Go Is a Compiled (vs. Interpreted, As Java Is) Language
\\
Go and Java Share Similar Program Structure \\
Go and Java Have Some Code Style Differences That
Influence How Code Is Structured \\
Both Go and Java Are Procedural Languages \\
Java Is an Object-Oriented (OO) Language, While Go Is
Not Fully OO \\
Java Is a Highly Functional Language, Go Is Less So \\
Java Is a Highly Declarative Language, Go Is Less So
\\
Many Java Features Are Annotation Driven \\
Go Does Not Support Exceptions \\
Both Java and Go Use Managed Memory (Garbage
Collectors) \\
Go and Java Both Support Concurrency but in Different
Ways \\
Go's Runtime Is Simpler Than the JRE \\
The Go Program Build Process Is Different \\
Go and Java Have Similar Release Cycles \\
2: What Java Has That Go Does Not \\
Multiple Assignments \\
Statements and Operators \\
Assert Statement \\
While and Do Statements \\
Throw Statement/Throws Clause \\
Strictfp, transient, volatile, synchronized, abstract,
static \\
Objects and Classes (OOP) and Inner Classes, Lambdas,
this, super, Explicit Constructors \\
Generic Types and Methods \\
Extensive Functional Programming Capabilities \\
Boxing of Primitive Values \\
Source Annotations \\
Multiple Visibilities \\
Overloaded/Overridden Functions \\
Formal Enums \\
Built-in Binary Data Self-Serialization \\
Concurrent Collections \\
3: A Deeper Comparison of Go and Java \\
Part II: The Go Language \\
4: Key Go Aspects \\
Simple Go Program Example \\
Go Packages \\
Go Comments \\
Go Build/Run Process \\
Go Playground \\
Go Integrated Development Environments \\
Running Go Programs \\
Building Go Programs \\
Bytecode vs. Real Code \\
Go Command-Line Tools \\
Tools Bundled in the Go Command \\
Other Tools \\
Go Runs Programs Instead of Classes \\
Go Memory Management \\
Go Identifiers \\
Go Scopes \\
Go Scopes vs. Go Source Files \\
Initializing Go Variables \\
Lifetimes of Go Identifiers \\
Go Module Summary \\
Go Assignments and Expressions \\
Text Formatting in Go \\
Goroutines \\
Issues with Concurrency \\
Go Concurrency \\
Goroutines by Example \\
5: Go Basic Features \\
Language Keywords \\
Operators and Punctuation \\
Go Operator Precedence \\
Go Built-in Functions \\
6: Go Types \\
Primitive/Built-in Types \\
Numbers \\
Characters and Strings \\
Reference vs. Pointer Types \\
Drill Down on Basic Data Types \\
Boolean Type \\
Integer Types \\
Floating-Point Types \\
When nil Can Go Wrong \\
Programmer-Defined Types \\
Arrays \\
Slices \\
Maps \\
Functions \\
Methods As Functions \\
Any Declared Type Can Have Custom Functions \\
Functions As Values \\
Structs \\
Structure Fields \\
Structure Literals \\
Nested Structures",
}
@InProceedings{Yoshikawa:2022:ENC,
author = "Taiki Yoshikawa and Hijiri Komura and Chihiro
Nishiwaki and Ren Goto and Kazushige Matama and
Katsuhiro Naito",
editor = "{IEEE}",
booktitle = "2022 {IEEE} International Conference on Consumer
Electronics {(ICCE)}",
title = "Evaluation of new {CYPHONIC}: Overlay network protocol
based on {Go} language",
publisher = pub-IEEE,
address = pub-IEEE:adr,
pages = "1--6",
year = "2022",
DOI = "https://doi.org/10.1109/ICCE53296.2022.9730323",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
}
@Article{Kirszenberg:2023:GFL,
author = "Alexandre Kirszenberg and Antoine Martin and Hugo
Moreau and Etienne Renault",
title = "{Go2Pins}: a framework for the {LTL} verification of
{Go} programs (extended version)",
journal = j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER,
volume = "25",
number = "1",
pages = "77--94",
month = feb,
year = "2023",
CODEN = "????",
DOI = "https://doi.org/10.1007/s10009-022-00692-w",
ISSN = "1433-2779 (print), 1433-2787 (electronic)",
ISSN-L = "1433-2779",
bibdate = "Sat Jun 3 14:59:07 MDT 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib;
https://www.math.utah.edu/pub/tex/bib/sttt.bib",
URL = "https://link.springer.com/article/10.1007/s10009-022-00692-w",
acknowledgement = ack-nhfb,
ajournal = "Int. J. Softw. Tools Technol. Transfer",
fjournal = "International Journal on Software Tools for Technology
Transfer",
journal-URL = "http://link.springer.com/journal/10009",
}
@Book{Leiva:2023:NAG,
author = "Nicolas Leiva and Michael Kashin",
title = "Network Automation with {Go}: Learn how to automate
network operations and build applications using the
{Go} programming language",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "xviii + 423",
year = "2023",
ISBN = "1-80056-092-3 (paperback), 1-80056-101-6 (e-book)",
ISBN-13 = "978-1-80056-092-5 (paperback), 978-1-80056-101-4
(e-book)",
LCCN = "QA76.73.G63",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
tableofcontents = "Introduction \\
Go Basics \\
Getting Started with Go \\
Networking (TCP/IP) with Go \\
Network Automation \\
Configuration Management \\
Automation Frameworks \\
Network APIs \\
OpenConfig Network Monitoring \\
Expert Insights \\
Appendix: Building a Testing Environment",
}
@Book{Tolaram:2023:FSW,
author = "Nanik Tolaram and Nick Glynn",
title = "Full-Stack Web Development with {Go}: Build your web
applications quickly using the {Go} programming
language and {Vue.js}",
publisher = pub-PACKT,
address = pub-PACKT:adr,
pages = "xvii + 282",
year = "2023",
ISBN = "1-80323-419-9 (paperback), 1-80324-391-0 (e-book)",
ISBN-13 = "978-1-80323-419-9 (paperback), 978-1-80324-391-7
(e-book)",
LCCN = "QA76.73.G63",
bibdate = "Mon Dec 18 09:08:05 2023",
bibsource = "https://www.math.utah.edu/pub/tex/bib/go.bib",
acknowledgement = ack-nhfb,
tableofcontents = "Preface \\
Part 1: Building a Golang Backend \\
1: Building the Database and Model \\
Technical requirements \\
Installing Docker \\
Setting up Postgres \\
Designing the database \\
Installing sqlc \\
Using sqlc \\
Setting up the database \\
Generating CRUD with sqlc \\
Building the makefile \\
Summary \\
2: Application Logging \\
Technical requirements \\
Exploring Go standard logging \\
Using golog \\
Local logging \\
Writing log messages to the logging server \\
Configuring multiple outputs \\
Summary \\
3: Application Metrics and Tracing \\
Technical requirements \\
Understanding OpenTelemetry \\
The OpenTelemetry APIs and SDK \\
Tracing applications \\
Installing Jaeger \\
Integrating the Jaeger SDK \\
Integration with Jaeger \\
Adding metrics using Prometheus \\
Adding metrics using Prometheus \\
Running docker-compose \\
Summary \\
Part 2: Serving Web Content \\
4: Serving and Embedding HTML Content \\
Technical requirements \\
Handling HTTP functions and Gorilla Mux \\
Hello, World with defaults \\
Building on the basics with Gorilla Mux \\
Rendering static content \\
Rendering dynamic content \\
Using Go embed to bundle your content \\
Summary \\
5: Securing the Backend and Middleware \\
Technical requirements \\
Adding authentication \\
Creating our dummy user \\
Authenticating a user \\
Adding middleware \\
Basic middleware \\
Adding cookies and sessions \\
Cookies and session handling \\
Storing session information \\
Using Redis for a session \\
Summary \\
6: Moving to API-First \\
Technical requirements \\
Structuring an application \\
Defining packages \\
Exposing our REST API \\
Cross-Origin Resource Sharing (CORS) \\
JSON middleware \\
Session middleware \\
Converting to and from JSON \\
Defining request model \\
Defining a response model \\
Reporting errors with JSON \\
Using JSONError \\
Using JSONMessage \\
Summary \\
Part 3: Single-Page Apps with Vue and Go \\
7: Frontend Frameworks \\
Technical requirements \\
Server-side rendering versus single-page apps \\
Introducing React, Vue, and more \\
React \\
Svelte \\
Vue \\
Creating a Vue app \\
Application and components \\
Login page using Vue \\
Using ViteUsing Vue Router to move around \\
Routing the login page \\
Summary \\
8: Frontend Libraries \\
Technical requirements \\
Understanding Vuetify \\
Setting up Vuetify \\
Using UI components \\
Understanding Buefy \\
Bulma sample \\
Setting up Buefy \\
UI components \\
Validating data entry with Vuelidate \\
Better input handling with Cleave.JS \\
Summary \\
9: Tailwind, Middleware, and CORS \\
Technical requirements \\
Introducing Tailwind \\
Creating a new Tailwind and Vite project \\
Consuming your Golang APIs \\
CORS for secure applications \\
Creating Vue middleware",
}
