Julian Simioni’s Blog

It’s time for another year of book reviews! This was not the year where I read the most, but those I got to I really enjoyed.

The Brilliant Disaster by Jim Rasenberger

This is an incredible story that is so much more complex than is capable of being understood just from popular knowledge about the famous events involved.

It’s a timely book to read and will continue to be relevant as we continue to discover more and more negative effects of the USA’s involvement in other countries affairs.

Chasing Space by Leland Melvin

The path astronauts take to space is not always a direct route, and no one can speak to that truth more than Leland Melvin, the only professional football player to also fly in space and visit the International Space Station.

This book is a must-read for those interested in the space program, but not for the reasons one might expect. Our nation and world needs, more than ever, to hear stories about the challenges people of color and other minorities face to get to the places white people have been from the beginning. Leland Melvin tells that story well and we should listen.

Kubernetes: Up and Running by Kelsey Hightower, Brendan Burns, and Joe Beda

Kubernetes has been one of the hottest technology topics of the year. The authors of this book have been around the scene since the very beginning. This is a short book, perfect for ensuring you know the core concepts of, and have a basic familiarity with, Kubernetes.

There is obviously much more to learn, but having confidence in your base knowledge is well worth the time. In fact, I am now purchasing other books in the O’Reilly “Up and Running” series expecting to see similar benefit.

Cloud Native Infrastructure by Justin Garrison and Kris Nova

The technology world is constantly changing and those of us who deal with software infrastructure would do well to read this book. Unlike Kubernetes: Up and Running, you won’t run to the command line and immediately put to use the knowledge from this book. However, after reading this book you will think about the changing trends of this industry with a bit more clarity.

I find myself frequently thinking back to nuggets of information from this book when weighing decisions for new software project architecture, and likely will for some time.

A Room of One’s Own by Virginia Wolf

If you adjust the currencies for the present day (£500/yr won’t really cut it anymore), you’d be hard pressed to find any part of this book that isn’t just as relevant today as it was almost 90 years ago. Like the stories from people of color, we need to listen to stories from women just as much today as in 1929.

Wolf’s writing style is wonderful: elegant, flowing, deep, and complex. I’d like to think I recognize elements of it in the writing of talented women I read today. It would makes sense that this is true.

The Manager’s Path by Camille Fournier

This is one of those books where you are actually reading about yourself. Hopefully, it’s in the incredibly useful descriptions of how to be a good employee/manager/CTO/etc that are in this book.

Most likely, the toughest but most useful parts of this book will be when you see a bit of yourself in the “Good Manager/Bad Manager” sections that detail various levels of unhelpful behavior that all sorts of team members can exhibit. It was definitely true for me, but that’s part of what makes this book so helpful.

The Secret Race by Tyler Hamilton and Daniel Coyle

We all knew professional cycling was full of performance enhancing drugs. But there was always a shroud of mystery and just enough unknown to ignore it or make it not worth thinking about. Obviously that’s no longer true. Tyler Hamilton does an incredible job with a first hand story that gives all the details of what being a top level pro cyclist was REALLY like.

It may not really make pro cycling appealing, but if you ever thought about living in Girona, Spain, you will think about it even more after this book.

Lance Armstrong’s War by Daniel Coyle

I read this book many years ago (before I was writing about the books I read). Back then, I treated it like a bible. What you wanted to aspire to, how you should act, if you wanted to become a true cyclist.

I don’t feel that way anymore. The second time reading this book, I read it as a companion to The Secret Race. When Coyle wrote this book, he could only hint at the things he knew about the real state of professional cycling. And he didn’t know nearly as much as we all do now.

Reading these two books is a great combo. One is direct with every detail. Lance Armstrong’s War is best if you read behind the lines. Most of the wild speculation about how corrupted professional cycling might be turned out to be true.

Long Walk to Freedom by Nelson Mandela

This year, I didn’t write my reading list in the order I completed books, because I had to save this one for last. Without a doubt, this is the best book I have ever read.

Nelson Mandela tells a story with a unique blend of clarity, emotion, humor, and care. And the story he has to tell is one of the most important of the 20th century.

Throughout this book I was brought to laughter, and to tears. I felt hope and despair. I was along for the entire journey with Mandela and 40 million South Africans.

As an added bonus, I read much of this book while in Cape Town, South Africa. It is not lost on me that while I was reading, I was smelling the exact same ocean air that Mandela was smelling when he wrote much of it from a few miles away on Robben Island.

After I was done, I spent hours reading other accounts. A huge treasure we have today is that there are countless videos of Mandela available instantly on the internet. Some of them cover his speeches or other events he wrote about in the book. I can confirm that his incredible wit, charm, and unstoppable vision is as present when he is speaking live as when he has endless hours in his cell to write down his thoughts.

I can’t recommend enough a trip to South Africa and a read of this book. But if the cost of flying almost to one end of this Earth is enough, at least read the book.

As part of setting up a new laptop recently, I was setting up git commit signing.

Despite having most of my configs in a git repository or otherwise tracked, I ran into a problem with setting this up.

Here’s the error:

1
2
3

$ git commit
error: gpg failed to sign the data
fatal: failed to write commit object

And the answer (for me):

Make sure the user.signingkey option in your .gitconfig is in the correct format! This is very silly, but there are some easy ways to get it wrong. First, some correct examples.

Standard long key format (recommended)

1
2
3
4

[user]
    name = Julian Simioni
    email = julian@simioni.org
    signingkey = 0x4CEEB1E5A7FD15E1

That’s 0x followed by the last 16 characters of your key id. At least as of gnupg 2.2.0 its the standard output of a command like gpg --list-secret-keys

Long key format without the hexidecimal prefix

1
2
3

[user]
    # ...
    signingkey = 4CEEB1E5A7FD15E1

Still 16 characters, but without the prefix clarifying that the value is written in hexidecimal.

Short key format (works, but not recommended)

1
2
3

[user]
    # ...
    signingkey = A7FD15E1

This is the “short” format, consisting of only 8 characters. It works too, and was much more standard in the past. However its not recommended as its now far too easy to generate keys that have the same final 8 characters.

DOESN’T WORK: other key lengths

1
2
3

[user]
    # ...
    signingkey = CEEB1E5A7FD15E1

You might be assuming, like I did, that GPG and git would be smart enough to allow you to use any suffix of your key, much like git allows you to use any unique prefix of a git commit hash. That is not the case. I suppose it makes sense. Oh well.

Other useful debugging steps

While in my case the issue with my commit signing was simple user error, I did go through quite a few other debugging steps, and they were helpful in figuring out where the error was not! Here they are in case they are useful to me again later (quite likely), or others.

Many of these came from this helpful Stackoverflow thread.

Ensure basic encryption works

A simple way to test gpg and your secret key itself is to issue a command like the following:

1

echo "test" | gpg --clearsign

This will send a small bit of text (“test”) to gpg, and have it print out the same text, but with a plaintext signature attached. If it works, then you know quite a few things are working: gpg itself, your secret key, whatever method you are using to enter the passkey to your key (if you have one, which you should!), etc.

GPG Agent settings, or lack thereof

GPG internally uses an “agent” program. Basically, whenever you run gpg, it launches a process in the background that will stick around. That process is used to remember your passphrase temporarily, for convenience, and probably other things.

In the past, ensuring the gpg command you run on the command line can communicate with this agent has been challenging. If you’ve ever seen instructions regarding adding various GPG_AGENT_INFO environment variables, its an attempt to properly set up this communication channel.

The good news is that as of GnuPG version 2.1.0, none of this is needed. There is now a “standard” method of connecting to the agent and everything is supposed to just work. Compare the instructions in the documentation for version 2.0 and the latest version to see what I mean.

GPG_TTY environment variable

This variable is important to set up. It will help GPG know which terminal it is running on, so that the prompt to enter your key passphrase is shown in the correct place. Again, from the GnuPG documentation, this will do the trick:

1
2

GPG_TTY=$(tty)
export GPG_TTY

Handling local terminal and SSH connections gracefully

There’s nothing worse than not being able to use gpg because you SSHed into your computer, and when you ran gpg, it popped up a dialog box to enter your passphrase on the computer display itself, rather than in your SSH session.

Fortunately, its easy to tell pinentry, the underlying program responsible for managing passphrase entry, to do the right thing during SSH sessions.

1
2
3

if [[ -n "$SSH_CONNECTION" ]]; then
    export PINENTRY_USER_DATA="USE_CURSES=1"
fi

This comes from the GnuPG Gentoo Wiki article.

Pretty fancy.