It is hard enough to remember my opinions, without also remembering my reasons for them! 

~ Nietzsche, as quoted in Moore’s and Mertens’ The Nature of Computation (Oxford University Press)

Simple can be harder than complex; you have to work hard to get your thinking clean to make it simple. 

~ Steve Jobs

INTRODUCTION

Without a shadow of doubt, Go is extremely well-positioned to be the go-to language for writing modern (and maintainable!) programs which can tackle head-on the unique challenges introduced by mushrooming infrastructure that operate at massive scales. Yep, I can tell from first-hand experience (over the past one year) that Go’s got what it takes to meet the demands for delivering on highly scalable, ruthlessly efficient (and sanely maintainable!) software to keep up with user demands.

In case you haven’t noticed—and hey, no worries if you haven’t!—two colorful introductions to (well, more like adventures in) have already appeared earlier on our digs here:

• The Go Programming Language
• Further Adventures In Go Land

Rest assured: No boring treatise (on Go language arcana or stuff like that) will be found in either of the aforementioned intros. Just a couple of no-holds-barred cruises through the rollicky landscape of Go 👞 👡 👣 👢

What’s Coming Up?

So let’s see how the talk so far (aka the preamble) shapes up in this post because—more so than in any earlier blog post—I’m taking inspiration this time from the inimitable Irish playwright and polemicist George Bernard Shaw when he spilled his beans and said that, “My method is to take the utmost trouble to find the right thing to say, and then to say it with the utmost levity” 👻

And yeah, don’t you just take my word for it; read on to find out how you can benefit today from what I have to offer: In casting a glance back at my (ongoing) journey to Go enlightenment, here’s my take on how (and exactly why) a handful of books have proven incredibly helpful to me.

The List

So I’m about to take an opinionated look at each one of the following books, in turn:

1. The Go Programming Language by Alan A. A. Donovan and Brian W. Kernighan (Addison-Wesley Professional Computing Series)
2. Learning Functional Programming in Go by Lex Sheehan (Packt Publishing)
3. Go in Action by William Kennedy, Brian Ketelsen, Erik St. Martin (Manning Publications)
4. Programming in Go: Creating Applications for the 21st Century by Mark Summerfield (Addison-Wesley Professional)
5. Concurrency in Go: Tools and Techniques for Developers by Katherine Cox-Buday (O’Reilly Media)
6. Go in Practice: Includes 70 Techniques by Matt Butcher, and Matt Farina (Manning Publications)
7. Go Web Programming by Sau Sheong Chang (Manning Publications)

My hope is that you’ll thereby be armed with the knowledge of which Go resources to get your hands on (to help you grok Go at your own pace.)

Atmospheric (Barometer) Check

Know, too, that I’ve taken great care in preparing the atmosphere (yeah!) in each one of the (soon-to-appear) pictures in this post. The goal: Make your cruise through the rollicky landscape of Go enjoyable! And if you really must know more about those two figurines—the iconic British telephone booth and Tintin the sleuth—in the topmost picture (plus in a bunch of upcoming ones), such as where came from, then I refer you to Yer Edinburgh Ode to Microservices for the unabridged, gory details, which are way too much to fit in here…

Look Who’s Squawking!

Oh, and no matter what else you do—and even if you don’t read a single one of the seven or so reviews coming up—please know that it’s my solemn duty to inform you that you are not, I repeat, you are not allowed to scroll all the way to the bottom of this post. I mean, do not whizz right to the scoop on the dilemma facing your blogger, complete with a parrot picture like the one above, if that reminds you even remotely of the Monty Python Flying Circus skit where an irate customer goes to a pet shop to register his complaint about a dead parrot!)

Hint: The dilemma your blogger faces has to do with how—once the visitor count at our old-and-no-longer-maintained digs had soared past 100,000—folks still keep going to our old blog site (aka our old digs) and not coming here (to our new digs.) What gives? Still scratching my head…

Anyhow, remember that you’ll want to check out the reviews below first, as you merrily wend your way to the grand finale involving the scoop (flagged by the reappearance of the parrot picture above). And you’re, like, What?! 

Forbidden Knowledge

Listen, for crying out loud, I told you just a moment ago that you’re forbidden from whizzing—aka blissfully and mindlessly scrolling at warp speed—to the bottom of this post. Surely you have the self-control to stay the course. No? Surely you have the will-power to delay gratification and (momentarily) keep away from checking out the happenings which involve an irate customer goes to a pet shop to register his complaint about a dead parrot. No?

Good luck with delaying gratification (that serpent in the garden), though something tells me that you can muster resolve: So while you grapple with your will-power dilemma, this one of your own making—and ready or not—we now dive into our reviews of the finest (book-format) wisdom that will help you navigate the rollicky Go landscape without sweat…

All buckled-up?

#1. The Go Programming Language by Alan A. A. Donovan and Brian W. Kernighan (Addison-Wesley Professional Computing Series)

This fine—though admittedly terse—book should be near the top of your list on the way to Go enlightenment. It is to Go what The C Programming Language was to C (No kidding, C is the grand-daddy of Go.) Having said that, I rush to caution you (especially if you’re coming brand new to Go) against attaching anything more than (some) semantic similarity between the two languages (i.e. Go and C), because each of these two languages solves completely different sets of problems.

Yes, you may have heard that Go is the C of the 21st century; and yes, Go inherits from C its expression syntax (every bit as terse as that of C), its control-flow (whittled-down statements), its basic data types (compact and efficient), call-by-value parameter passing (never mind you, legions of Java programmers), pointers (should I even broach this subject before someone cries uncle!), and finally—as rightly pointed out by Donovan and Kernighan, the co-authors of this fine book—Go inherits (from the C tradition) programs which, “compile to efficient machine code and cooperate naturally with the abstractions of current operating systems.” (Lots more details, should you wish for more, that is, in )

In full candor—and sterling though it is—reading The Go Programming Language has, at times, felt like taking medicine… Right there you should have a clue that this book is going to be good for you! (At least that’s what I was always told: Medicine, especially the bitter one, is good for you!) Seriously, though, who reads programming language manuals for fun; trust me, if that’s your idea of fun, more power to you. But at the end of the day, this (reference) book is indispensable, so you might as well warm up to it. Yep, resistance will be mostly futile. Not only that, this books deserves to be read several times, not once; think of taking multiple doses of medicine. Makes sense? Surely you took all your medicines when you had to, right? What?! (OK, we’re not going there…)

Segueing a bit: At my first job out of grad school—with Schlumberger—back in the day (1995), I did virtually all my programming in C. And just as The C Programming Language remained chained to my desk, nowadays The Go Programming Language plays that captive role instead. Doggone it, there’s even some elegant beauty in its terse narrative, come to think of it, like the kind of austere beauty which a smart cookie (the British mathematician and philosopher Bertrand Russell) kept talking about, for example when he opined that

Mathematics, rightly viewed, possesses not only truth, but supreme beauty—a beauty cold and austere, like that of sculpture, without appeal to any part of our weaker nature, without the gorgeous trappings of painting or music, yet sublimely pure, and capable of a stern perfection such as only the greatest art can show. The true spirit of delight, the exaltation, the sense of being more than Man, which is the touchstone of the highest excellence, is to be found in mathematics as surely as poetry.

And to that I’ll add another quality which this book shares, and not with medicine—I wanted to rule that out since we were chatting just a minute ago about how stuff that’s good for you sure can taste like medicine—but with math: Rigor. A lot of rigor. Yep, this book is a keeper. (Just remember not to sleepily put your copy of The Go Programming Language in the medicine closet late at night. OK, so it’s the medicine that goes in there; books go in your bookshelves, or on your desk, provided there’s any flat surface available!)

#2. Learning Functional Programming in Go by Lex Sheehan (Packt Publishing)

This is the book that finally helped me get Go. What more can I say?

I was tempted to move this book to the top spot (on this list) but finally decided against that act as being too heretical; I mean, the canonical book—Donovan and Kernighan’s The Go Programming Language—just has to have that honor (if for no other reason than that the legendary Brian Kernighan is one of its authors!)

Seriously though, and coming back to the book which comes in at the second spot—Learning Functional Programming in Go—let me just say this: I am simply stunned by the uniformness of its top-notch quality content. This isn’t the kind of stuff that some really smart (Go) software practitioner just woke up one morning and wrote up; it comes from someone with deep industry experience, with tremendous insight into what makes programming tick, plus a mastery of explaining knotty concepts simply and with a pleasingly engaging writing style. Take this from someone (hey, that’s yours truly, for crying out loud) who knows a thing or two about Functional Programming (aka FP, since using the minimum possible to stand in for the maximum possible is a core tenet of FP, going meta and a tad recursive here, heh)—and regular readers of this blog are likely fully aware of that anyway. So there.

OK, over here now, and back to our review: So this amazing book could not have come to my attention at a better time: I had dived deep into using the Go programming language last year (circa early-to-mid 2018), ramping up to work on an awesome open source (polyglot language) project hosted by The Linux Foundation: EdgeX Foundry (As a committer on EdgeX, I have been using Go exclusively, full time, for a while now; coming as I did from a deep background in Java and Scala (each an awesome language in its own way), I had to repurpose my programming style (and mindset) from the ground up to learn how to do things the Go way.

A word to the wise while we’re at it: Go is incredibly opinionated, but in a genuinely good way. You will be relieved of drudgery and verboseness, plus end up feeling far more confident in truly understanding, among other things, what Rob Pike had in mind when he said—and I’m paraphrasing from memory here—that “Less is exponentially more.”) It will take some time. Take heart, though; it can be done.

If you think about it—in the end—everything can be (and should be) related, simple, and well-designed. The biggest problem, IMHO, especially with FP, is that the smart guys who originally saw how it works, seem to have the hardest time making it easy to understand. But that’s not a problem (in the least, whatsoever) with Learning Functional Programming in Go: Somehow it manages to capture tough ideas (think “essential complexity”) and strips away their “accidental” complexity. And that’s a big deal, if you ask me.

With a nod to the mind-bending observation that “A language that doesn’t affect the way you think about programming, is not worth knowing” (by Alan Perlis, the very first recipient of the Turing Award), I am especially pleased to have this book by Lex Sheehan at my side as a trusty resource. Among other things, working intensively with Go has forced me to rethink what it means to leverage a programming paradigm in the service of creating great software that’s designed to unfold, to emerge—so to say—and to delight customers.

You are bound to get a ton out of Learning Functional Programming in Go. I did. Don’t miss it!

#3. Go in Action by William Kennedy, Brian Ketelsen, Erik St. Martin (Manning Publications)

In a way, this is a language lawyer’s book: It dives remorselessly—without so much as wincing—into the guts of the Go language. To take just one example, in educating the reader about the innards of “slices,” the authors let us in on the fact that “Slices are tiny objects that abstract and manipulate an underlying array. They’re three-field data structures that contain the metadata Go needs to manipulate the underlying arrays.” What makes it all hang together (as in this tiny example on the subject of “slices,” and elsewhere throughout the book) are the copious and thoughtfully lavish illustrations.

Yes, there’s a ton of helpful details (on the ins and outs of programming with Go) to be found between the two covers of Go in Action—which is why I bought it in the first place!—the narrative never gets bogged down, though. The authors somehow manage to keep things fun throughout by using copious examples that are well-chosen, thoughtful illustration, nicely annotated code, and stuff like that. It’s not a big book; decidedly slim and compact. Methinks that you will want to check this one out.

#4. Programming in Go: Creating Applications for the 21st Century by Mark Summerfield (Addison-Wesley Professional)

This is an excellent, but often-overlooked book. Why it remains overlooked, I don’t know: Maybe because its subtitle—Creating Applications for the 21st Century—puts programmers off as being too, um, “marketing”-speak or something? Seriously, though, Programming in Go: Creating Applications for the 21st Century is extremely well-written, so I would urge you to pretend that its subtitle doesn’t even exist. (Gosh, this is getting a tad existentialist, and did I even bring this up? “Akram, how could you?!”, I hear you say. Oops.)

Anyhow, one thing I like a lot about this book is the sure-footedness with which it fearlessly tackles the task of showing you how to internalize the mindset of programming in Go the way this language was intended and designed for. While I haven’t read any other books by its author (Mark Summerfield), he is clearly a master expositor, paring explanations down to their essential complexity, stripping away extraneous—darn, I thought I had been doing good lately on the pact with myself to steer clear of sesquipedality*—and accidental complexity.

What you get is a down-to-earth set of coherent narratives that have clearly been thoughtfully woven together in the service of educating the next generation of Go programmers. Calling all Gophers!

Whoa! A lightbulb just went off—what with my waxing lyrical about this book’s vision of educating the next generation of Go programmers—and it dawned on me that similar thoughts must have surely made a foray or two into the collective consciousness of the marketing folks who came up with its dazzling subtitle—Creating Applications for the 21st Century. Hey now, I was just sayin’.

If I ever meet the author, I’m going to tell them what a splendid job he has done. Meanwhile, if you run into him first, could you please tell him that I said hello?

Hey, what are you waiting for? Go get this book. Now.

*Sesquipedality (is the use of big words, literally those that are “a foot and a half” long, according to Bryan A. Garner, in his fine tome called Garner’s Modern American Usage, published by the venerable Oxford University Press.)

#5. Concurrency in Go: Tools and Techniques for Developers by Katherine Cox-Buday (O’Reilly Media)

A great second—or possibly even third—book on Go programming for you could be Concurrency in Go: Tools and Techniques for Developers by Katherine Cox-Buday. This delightfully written book makes, in turn, reading it a pleasure. Everything you ever wanted to know about Go concurrency is in here—all presented in easily digestible chunks.

Let’s face it: Doing concurrent programming in any programming is hard, though Go makes that effort (considerably) more tractable with its amazing programming construct called “channels” (For more details, I invite you to check out: Some Of The Coolness Go Has To Offer) It’s all inspired—and informed—by the notion of communicating sequential processes (CSP), which originated in Tony Hoare’s wonderful white paper in 1978 (In a nutshell, all processes communicate and synchronize via channels.) What makes Go especially cool is that it’s very core is permeated by CSP (again, think “channels”) 📬

I guess all that is is a roundabout way of saying that we programmers still—and will conceivably forever—need all the resources we can get our paws on when it comes to concurrency. But rejoice. All the good stuff (and no fluff) are in this fine book by Katherine Cox-Buday. She is a gifted writer who knows well how to guide the reader through the thicket of concepts that are part of the (Go) concurrent programming landscape. To take one small example, here is just one of the (many) pointers that Katherine shares in the Preface to her book:

When I read technical books, I usually hop around to the areas that pique my interest. Or, if I’m trying to ramp up on a new technology for work, I frantically skim for the bits that are immediately relevant to my work. Whatever your use case is, here’s a roadmap for the book with the hopes that it help guide you to where you need to be!

Now that’s my kind of writing style, one that I’d be happy to sign my name to!

There simply isn’t—and likely never will be—any pixie dust (who knows for sure, so we’re calling Tinker Bell to be safe) that one wishes one could sprinkle on their codebase and make it magically concurrent. At least I’m not holding my breath for that kind of transformative agency! But the closest thing I’ve seen (in terms of clear, engaging, and thoughtful guidance in the area of Go concurrency) is right there between the pages of this fine book.

Enough said.

#6. Go in Practice: Includes 70 Techniques by Matt Butcher, and Matt Farina (Manning Publications)

Maybe Fleetwood Mac (hey, does anyone even recognize the name of the remarkable light-rock music group from the 80s?) knew a thing or two about Go programming back when they released their song Go Your Own Way, way before Go was a twinkle in the eyes of its co-creators (Rob Pike, and Ken Thompson, and Robert Griesemer.)

But I (nearly) digressed (And I’m hearing you loud-and-clear when you say, “Akram, stop, don’t you even think of pulling off another one of your random digressions the way you wantonly did around on our old digs!”) Heh, heh, hey, relax: There is a subtle—I was going to say subliminal, but bit my lips—method to this madness (i.e. my seeming digression to Fleetwood Mac). “Like, what?,” you ask.

Glad you asked: So there is the Go way of doing things, and then there’s your of doing things (Spoiler alert: Never the twain shall meet.) If you are coming to Go from a different programming paradigm (such as the object-oriented, imperative, or even the functional paradigm), much as I did about a year ago, then you’re gonna find out quickly that there’s a delta between the Go way of doing things and your way of doing things. Period.

And that’s precisely where Go in Practice: Includes 70 Techniques comes in. The authors have done a pretty good job—with a reasonable amount of handholding—of showing what the Go way of doing things really looks like. While it’s not all roses (i.e. the Go way of doing things), there definitely is a method to their madness in having designed Go the way they did (referring again to the three amigos: Rob Pike, and Ken Thompson, and Robert Griesemer.)

So take it from yours truly, somebody who’s been there and done that: Save yourself a lot of needless pain in your practice of Go programming and get familiar with the 70 techniques explained engagingly in this book.

But if you still want to go your own way… Look, I’ll be the last one to stand in your way. Just saying.

#7. Go Web Programming by Sau Sheong Chang (Manning Publications)

What, web programming with Go: Are you serious?! OK, so even if you never end up writing even a single line of web-centric Go code, don’t pass up on this fine book: It’s got plenty to offer to those who are not web developers. In fact—and this is likely what gets lost on most people when they glance at the somewhat poorly-named title (Go Web Programming)—this fine book has much to offer to back-end developers (which is the Go programming community, predominantly, I’d say.)

The author, in fact, pointedly notes in his Preface to the book that “It’s all about HTTP again and how to deliver content and data through it.” So there you have it. Now go forth and tackle your eventual consistency concerns head-on!

Yep, the author gets the simplicity and refreshing directness of the language—that’s what I had in mind when I put that Steve Jobs quote up atop this post (“Simple can be harder than complex; you have to work hard to get your thinking clean to make it simple“) in case anyone noticed. And I was not being an Apple fan-boy.

Superbly explained coverage of a bunch of topics (at just the right level of detail), topics that remain relevant to me on a daily basis—such as handling requests, processing requests, storing data, web services, and leveraging Go concurrency—make Go Web Programming a refreshingly welcome book. And yes, it’s eminently readable—not at the same level as Concurrency in Go: Tools and Techniques for Developers, but not terribly far behind either.

If you want to understand the relevance of HTTP to your programming (at the gut level), Go Web Programming is the book for you. Let’s all collectively forgive the somewhat ineptly-named title, and not pass up on its value proposition. This one’s another keeper.

#8. C: A Reference Manual (4th Edition) by Samuel P. Harbison, and Guy L. Steele (Prentice Hall Ptr)

Wait a second: So what, exactly, is a book on C doing here (on a purported list of Go books)? My reasoning is twofold:

1. Checking if anyone is even awake-enough to notice the appearance of a C book (in a list of, yes, Go books)
2. Reminding you—and here I’m being told that subtlety is my middle name—that it’s no coincidence that Go has been dubbed as the C of the 21st century.

And did anyone notice the name of the esteemed Guy Steele on the cover of this book? For those not familiar with his name, he just happens to be one of my all-time programming heroes—yep, right up there with (the late) John Vlissides—and is widely regarded as the father of Common Lisp. (Steele also happens to be the lead author of The Java Language Specification; by the way, he co-created the Scheme programming language while he was an undergrad.)

Should anyone be into writing operating systems code, by all means read this book; plus, learning C never hurt anyone (Ages ago, I did put up with a bunch of sleepless nights as I grappled with… C pointers!) At a minimum, check out C: A Reference Manual (4th Edition) to get a sense for what a magisterial writing style might look like when applied to technical subjects—think Artificial Intelligence: A Modern Approach (Pearson) by Stuart Russell (UC Berkeley) and Peter Norvig (Google).

Wait A Second…

“And surely you’re joking, Akram? You snuck in a parrot while we weren’t looking!”—Um, may I nudge you in the direction of scrolling down (past the parrot below) to find out?

Look Who’s Squawking (Again!)

Finally, a word on our old blog site (aka our old digs)…

It is no more; I mean, the old blog site is still out there, but it sure isn’t get updated (at least not by me!) So one more time—repeat after me—the old blog site is no more. Put another way, the old blog site has ceased to be! It has expired. Bereft of life, it rests in peace, etc. OK, let me spell this out…

Wait, and better still, allow me to point you to Monty Python’s Flying Circus, in particular the episode where a customer (named “C“, but of course) enters a pet shop, and has the following chat with the pet shop owner (named “O“, but of course).

Read at your own risk, as it might be side-splitting funny, even as it manages to shed (some, and only marginal) light on how it came to be that your blogger keeps wondering why—once the visitor count at our old-and-no-longer-maintained digs had soared past 100,000, thank you!!—folks still keep going to our old blog site (aka our old digs) and not coming here (to our new digs.)

Like, what’s up with that? (Well, there’s nothing like taking the tram below to a smidgen of the fabled skit from the one and only Monty Python’s Flying Circus; I’ll meet you on the other side as you disembark your tram ride.)

Aha, you made it to the other—dark—side! So let’s dive right into a tiny snippet from that Monty Python’s Flying Circus skit. (I’ll wait for you while you do…)

So there you have it: My old blog site’s metabolic processes are now history! That’s actually an unerringly apt description since the content (on the old site) isn’t growing, although it isn’t shrinking either; for some reason, though, innocent folks keep flocking to that (old) site, and not this (new) one.

Waaah!! What am I doing wrong? Somebody? Anybody?!)

Marveling At The Designs Of Nature

To calm our (collectively) frayed nerves, we’re going to do one thing, right now: We are going to treat ourselves to the soothing balm of nature, busily working away, hand-crafting ineffable designs (Our Go programs—or programs written in any other language, for that matter—can only aspire to be but crude approximations of the ineffable designs of nature. So go ahead, take in the blissful, organic growth in the pic below (It’s a surreal-looking marvel that is a fine specimen of the Campanella species, which is a genus of fungi in the Marasmiaceae family—bottom-line is that you can stare at the mystic unfolding of nature; just make sure you don’t eat any of that Campanella!)

So this post—hey, I still like to think of these critters that you all blithely call “posts” as “essays,” really—was going to end now, except that…

Campanella

“Except what?” you ask, understandably so. Well, it goes like this: Methought I heard something ‘bout Campanella! And I can’t let that just go. You know?

So, you ladies and gentlemen out there in ether space, dear Readers that you all are—for crying out loud—the gloriously-named Campanile happens to be the (more) popular name of the famed tower whose official name is Sather Tower (a monumental and marvelous bell tower you’ll find planted smack in the middle of the Berkeley campus of the University of California.) Read on if you don’t believe me…

The Campanile

“Yeah right, Campanella, Shampanella, we don’t believe a word of what you say, Akram!”

Hah, I knew, I just knew this was coming (my way, as in, right into my parlor). And I’m prepared. Woohoo! For picture proof that I was there, (at the Campanile, mind you, and not at the site of the Campanella genus of fungi, because I sure don’t go near no fungal critters growing in any old underbrush) I invite you—yep, you all, fine ladies and gentlemen of the jury—to check out Exhibit A (the pic below).

Exhibit A

That’s me in front of, yep, the Campanile. And should you perchance have not had enough of all this—oh my, the ravenously incandescent curiosity you all bring lights me up!—and want still more on my visit to The University of California at Berkeley campus (from a while ago), then allow me to point you to the following coordinates: Software Actors, Rare Benefactors. (Compelled by the mores of keeping the truth in advertising, I hasten to add: That essay is not all—or even mostly—about my visit (to UC Berkeley), but it sure has a bit of it.)

So once you have, in turn, visited the coordinates above, to check out the intriguing (and even beguiling) mysteries of software actors—that is, should your burning curiosity have emboldened you to undertake the danger-fraught, perilous pilgrimage—and you then decide to come back to this essay…

OK, then we need to talk some about the recursive aspects of experience as we know it (in the spirit of something like those bouncy Clojure trampolines). Just sayin’ (But you can take me up on the offer, just not right now!)