A Go Developer's Notebook
Minimum price
Suggested price

A Go Developer's Notebook

or, What I Do During My Holidays

About the Book

This is the book that I wish had existed when I first started exploring the Go language, built around code examples I could have played with at my own pace.

It's also like the book I wish had existed when I first started programming - an amalgam of the magazine articles which taught me to code and the wisdom (or not) conferred by thirty-plus years of doing just that. I hope it's as readable to the interested teenager taking their first steps into hacking as it is the university graduate armed with a wealth of theory but looking for practical insight.

It's also more generally a book about reading and writing code, and about many areas of computing which fascinate me. Perhaps they'll fascinate you too!

One thing this isn't is a professional book, by which I mean that it's not concerned with helping a professional developer quickly transition from another programming language to Go. There are plenty of those already in print, written by much better teachers than me. Instead my aim in this text is to provide a much deeper exploration of subjects I'm interested in through the lens of Go, teaching the language almost as an after-thought.

The didactic style is brutally simple and old-school: write code, explain code, modify code, explain changes, repeat as necessary. Along the way I'll do my best to explain what each example is trying to achieve, and the thinking which evolves it towards its final form.

Each chapter is built around a particular programming task which I use to demonstrate how various features of the Go language can be used as well as to share many of the things I've learned during several decades of coding. Some of these programming tasks may appear deceptively simple, others totally irrelevant to the life of a commercial developer. I intend to disabuse you of both notions, whilst at the same time keeping this a Hacker's Notebook: depending on your outlook this is either a logbook of experiments undertaken and rabbit-holes delved in pursuit of knowledge, or a grimoire of the esoteric and unutterably unconscionable.

If the choice of subject matter at times seems eccentric, remember that my target audience is my teenage self, hunched starry eyed and clueless over an 8-bit micro, not the fortysomething code diva I've since become. My teenage self knew nothing about reading code, testing, refactoring, the scientific method, clean coding style, or academic theory.

As the reader you don't need to know any of these things either, though if you do I hope you'll still find some useful nuggets to add to your toolkit.

So in essence this is a book inspired by my love of programming for the sake of programming, my disillusionment with the widespread desire to teach professional programming at the expense of exploration and fun, and my hope that readers of all ages will find the same pleasure in reading this book that I've experienced in researching and writing it.

There's a google plus community for discussions and a public github repo with the code for each completed narrative section.

To further whet your appetite I provide a free sample comprising an introduction to concurrent network programming with Go that includes practical encryption and is probably sufficient for a professional developer to get up to speed with the language. If that's all you're after, enjoy this free gift.

I've also given a brief presentation on the philosophy behind this living book.

About the Author

Eleanor Loughlin-McHugh
Eleanor McHugh

London-based hacker Ellie has a passion for the esoteric corners of programming stretching back to her misspent teenage years. During the course of her career she's worked on mission critical systems ranging from avionics to banking security and now devotes her time to writing digital romances in Ruby and Go.

As a responsible parent she enjoys polyhedral dice, home brewing and gothic music.

Table of Contents

    • Preface
  • Introducing Go
      • Getting Started
      • So what is Go?
        • Open source
        • Efficient compilation
        • Efficient execution
        • Ease of programming
      • And where did it come from?
      • Into the wild
      • Where next?
    • Hello World
      • Packages
      • Constants
      • Variables
      • Functions
      • Encapsulation
      • Generalisation
      • Startup
      • HTTP
      • The Environment
      • Handling Signals
      • TCP/IP
      • UDP
      • RSA obfuscated UDP
      • Error Handling
      • Exceptions
    • Echo
      • Arguments
      • Flags
      • Command-line Boilerplate and Standard I/O
        • Conditional Flags
      • Errors
  • Going Loopy
      • Adventures in Iteration
    • Linear Sequences
      • The for {} construct
      • User Defined Slices
      • Iterating Through Arrays
      • Arrays and Slices Exposed
      • Iteration and structured types
    • mappings
      • Iteration and maps
  • Software Machines
    • Software Machines
      • array stacks
      • cactus stacks
      • hash maps
      • heaps
      • switch dispatchers
      • direct threaded dispatchers
      • indirect threaded dispatchers
      • assembler
      • tail calls
      • architectures
      • fun with types
      • timers
      • Instruction Set
      • processor core
      • accumulator machine
      • stack machine
      • register machine
      • vector machine
    • Software Machines
      • memory
  • Functional Programming
      • Metaprogramming and First-Class Functions
      • Pure Functions, Expressions, and Recursion
      • Partial Application and Currying
      • Lazy Evaluation and Memoization
      • Infinite Series and Data Structures
      • Immutability
      • Category Theory
    • Functions
      • The Machine View
        • Adding Human Readability
        • Procedures and Functions in Go
      • The Mathematical View
      • Simple Factorials
        • First-Class and Higher-Order Functions
        • Closures
        • Currying
      • Recursion
        • funcs() Which Call Themselves
        • Mathematical Functions Which Call Themselves
        • Error Handling the Go Way
        • Changing Types
    • Memoization
      • A Shallow Introduction to Big-O Notation
      • In-Memory Caching
        • Private Caches
        • Caches in Hashes
        • Once Upon A Flat File
        • Let’s Talk About Type
          • utility.go
          • cache.go
          • main.go
        • A Generalised Cache
          • cache.go
          • utility.go
          • factorial.go
          • diskcache.go
          • main.go
        • Explicitly Layered Caching
          • A Dedicated Memory Cache
          • Writing Files in a Functional Manner
          • Preventing Concurrent Writes
          • Sharing Locks Between Processes
  • Odds & Sods
    • Maps and Hashes
      • Go maps
      • A simple Map implementation
    • Types
      • Interfaces
        • Interfaces, pt 1
        • package adder
    • Pretty Pictures
      • Basic Mandelbrot
    • Phong Shading
    • Communication by Sharing
    • Concurrency
      • synchronous
      • asynchronous
      • map/reduce
      • map/reduce
    • Errors, Exceptions & Flow Control
      • Catch & Throw
      • Stack Traces
      • Exceptions
    • Duck Typing, Reflection and Type Manipulation
      • package generalise
      • raw
    • Beyond Go
      • Interfacing with Dynamic Libraries
        • SQLite 3
        • Ruby?
  • Notes

The Leanpub 60 Day 100% Happiness Guarantee

Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.

Now, this is technically risky for us, since you'll have the book or course files either way. But we're so confident in our products and services, and in our authors and readers, that we're happy to offer a full money back guarantee for everything we sell.

You can only find out how good something is by trying it, and because of our 100% money back guarantee there's literally no risk to do so!

So, there's no reason not to click the Add to Cart button, is there?

See full terms...

80% Royalties. Earn $16 on a $20 book.

We pay 80% royalties. That's not a typo: you earn $16 on a $20 sale. If we sell 5000 non-refunded copies of your book or course for $20, you'll earn $80,000.

(Yes, some authors have already earned much more than that on Leanpub.)

In fact, authors have earnedover $12 millionwriting, publishing and selling on Leanpub.

Learn more about writing on Leanpub

Free Updates. DRM Free.

If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).

Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.

Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.

Learn more about Leanpub's ebook formats and where to read them

Write and Publish on Leanpub

You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!

Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.

Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.

Learn more about writing on Leanpub