Adam Keys is Thinking

As self-driving cars inch closer to a daily reality, the Trolley Problem seems to have entered our lexicon. In short, should a self-driving computer choose to avoid hitting a bunch of people and kill its single occupant as a result? Turns out people expect the car to protect the greater good second and their own skin first.

Maybe out our current political environment of unfettered gun violence, climate change, Trump-lead racism, Brexit-fueled xenophobia, and general apprehension about losing what we thought we’d earned are a kind of longer-term but still serious Trolley Problem. Would you vote to improve society at large even if it meant taking yourself down a ego/prestige/money notch?

Well when I put it that way, things seem pretty bleak!

I happened across an Alan Kay essay, Enlightened Imagination for Citizens, and it kinda helped me get through that bleakness. Some highlights:

In a raging flood, a man risks his life to save a swept away child, but two years earlier he voted against strengthening the levee whose breaching caused the flood. During an epidemic people work tirelessly to help the stricken, but ignored elementary sanitation processes that could have prevented the outbreak. More astoundingly, as many as 200,000 Americans die each year from diseases spread by their own doctors who have been ignoring elementary sanitation (including simply washing their hands when needed), but who then work diligently to try to save the patients they have infected. Studies show that about 80% of Americans are “highly concerned” about climate change, yet this percentage drops to less than 20% when the issue is combined with what it will cost to actually deal with these changes.

Regarding our inability to reason about dynamic systems:

One of the reasons the consequences were not imagined is that our human commonsense tends to think of “stability” as something static, whereas in systems it is a dynamic process that can be fragile to modest changes. One way to imagine “stability” is to take a bottle and turn it upside down. If it is gently poked, it will return to its “stable position”. But a slightly more forceful poke will topple it. It is still a system, but has moved into a new dynamic stability, one which will take much more work to restore than required to topple it.

On acting now instead of acquiring a perfect answer or solution:

When the costs of an imperfectly understood event are high or essentially irreversible, measures have to be taken even when perfect proofs are lacking. This idea is understood by most developed societies—and carried out in the form of levees and pumps, food and water stocks, etc.—but is nonetheless resisted by many of the voting public.

Perhaps the solution is to get ourselves representatives that excel at reasoning and legislation instead of politics and fundraising?

One of the reasons we are a republic with a democratic base is that the representatives can be selected to be “the best and the brightest” from the population as a whole (this was another early ideal for the great American experiment). We could argue that the current representatives are “all too representative”, but this is part of a slide in our political and social systems that needs to be shored up and improved. The idea of “national service” is now just a whisper, but it is what needs to be brought back into the forefront of what it means to be a citizen.

What is technical leadership? Per Mature Developers, it's a lot of things. My favorites:

So one of the first and most important qualities of mature developers is they’re more often than not paying attention to what is going on around them. They’re deliberately taking their time to observe before proceeding (put succinctly as STOP; Stop, Take a breath, Observe, Proceed).

It is so hard for me to do the stop and breath part.

Sharing the [technical] vision with other involved parties not only serves as a perfect opportunity for practicing one’s skills to explain deeply technical terms and circumstances with non-technical people. It also serves the purpose to validate the vision in terms of relevance to business value and other aspects.

Assessing and understanding risks better puts them into a position where it’s also more likely they’ll actually take risks. Risks which, without the knowledge about business value and the bigger context, may look too big to be worthwhile. But not for mature developers who are able to see beyond the obvious risks and include more aspects into their judgement.

Managing risk, but not overmanaging it: also very difficult.

Previously: Thoughts on “Being a Senior Engineer”.

I write here in bursts. It confounds me as to what marks the beginning and end of those spikes. I have a few hunches:

• ambitions grow larger than my free time: it’s easier to hit publish on a self-contained thought than a connected series or magnum-opus essay
• intervention of life: work, vacation, various chores adults are expected to perform
• self-distraction: acting as a novelty junky rather than pushing one thing through to completion
• tweeting less: putting little thoughts into tweets means I’m driven to put slighly-not-little thoughts into blog posts
• reading less: reading interesting things drives me to (attempt to) write interesting things
• skipping record: I worry I’ve already had this thought and published it somewhere

Also sometimes I’m not quite sure how to end a thought like this and I wonder if I should worry about that and then I decide to let it slide.

Lately, I’m doing a weird thing when writing Ruby code. I’m trying to only put one idea or action per line. I’m not sure about it yet.

Here’s what a method to fetch item-y things might look like:

def fetch_items(options={})
  limit = options.fetch(:limit)
  timestamp = options.fetch(:timestamp)
  paged_helper = PagedHelper
  client = OurHttpClient

  responses = paged_helper.
    new(limit, timestamp).
    fetch_pages { |params| client.get(params) }

  responses.
    map { |r| JSON.parse(r) }.
    map { |h| ItemCollection.new(h) }.
    map { |ic| ic.items }.
    flatten
end

For the sake of comparison, here’s how I may have written that method a couple years ago:

def fetch_items(options={})
  helper = PagedHelper.new(limit, timestamp)
  responses = helper.fetch_pages { |params| OurHttpClient.get(params) }

  responses.map { |r| ItemCollection.new(JSON.parse(r)).items }.flatten
end

I like that the pace of reading the first example is even. You don’t arrive upon some monster line of code that does a multiple things. You don’t have to unpack what’s happening in a situation where you’re calling f(g(h(some_args))). It makes moving lines of code around much simpler because each one is only dependent on what comes before, and not what happens inside. It’s a little easier to write a three-part method, which I really like.

But still, I hesitate. My methods end up about 50% longer. Breaking up the Enumerable transformations into multiple loops instead of one loop doing a bunch of work is probably pretty slow. I have to come up with a lot of names (which is, I think a net good), some of which end up a little redundant.

I’ll let you know how it goes. It may not even survive code review, who knows!

I find methods/functions decomposed into three parts really satisfying. Consider a typical xUnit test:

def test_grants_new_role
  # setup
  user = make_user
  new_role = make_new_role

  # behavior under test
  user.add_role(new_role)

  # assert results
  assert_equal [new_role], user.roles
end

Lately I’ve been structuring Rails controller similarly:

def create
  # Extract inputs/parameters from HTTP request
  person_params = params.require(:person).permit(:name, :age)

  # Invoke behavior encapsulated in a Plain(ish) Ruby object somewhere
  user = UserService.create_user(person_params)

  # Check the result and make some HTTP output
  if user.persisted?
    redirect_to user_path(user.id)
  else
    @user = user
    render :new
  end
end

Clojure even has the let form which encourages this style:

; annotated from clj-http
; https://github.com/dakrone/clj-http/blob/master/src/clj_http/util.clj
(defn gzip
  "Returns a gzip'd version of the given byte array."
  [b]
  (when b
    ; set the table
    (let [baos (ByteArrayOutputStream.)
          gos  (GZIPOutputStream. baos)]

      ; do the work and clean up
      (IOUtils/copy (ByteArrayInputStream. b) gos)
      (.close gos)

      ; produce a result
      (.toByteArray baos))))

I don’t think there’s anything inherently wrong if a method or function isn’t organized this way. But when I read code structured this way, it feels less like a bunch of random logic and more like a cohesive unit that someone put time into thinking through how someone might try to understand it later. The Rule of Three rules everything around us.

Slight rant: versioning a (REST) API inflicts upon you a confluence of factors that will lead to pain no matter what you do.

You’re going to need to version things, which opens you to bikeshedding which True Scotsman approach to REST versioning you’ll use. Once you’ve expended tons of effort on how clients should specify which version they want (i.e. once you’ve just barely started), now you need to figure out how to make that work in your code. Which, after you’re done parsing the HTTP request (the easy part!), is almost certainly going to lead to some unruly layer(s) of indirection. At which point you’re going to hate life and never want to introduce another version ever again. And you won’t even be close to finished.

I hope that, between JSON API and GraphQL, letting the client specify what they want ends up proving way better than relying on the server to carefully (or possibly carelessly) hand craft just the right data for the client.