walls.corpus

By Nathan L. Walls

  • Paragliding/Wrightsville Beach
  • Lighting Prep/Raleigh
  • White Tiger/Pittsboro
  • Serval/Pittsboro

New year, new gig

Ralph/Raleigh

I announced on Twitter last week that I wrapped up my time at WebAssign and started at thoughtbot’s Raleigh office.

WebAssign is working on some amazing ways to help both instructors and students in STEM courses be more effective. The team I just left is a great bunch of fellows. I wish them and the company well.

The new gig takes me away from the environment tooling and automation that I was working on and more toward straight application development. After spending the last three years on operations-focused development, I’ll be building applications that help developers and designers at thoughtbot and for our clients.

I spent a fair amount of time researching thoughtbot ahead-of-time and, as good as things looked from what I could see from the outside, after about a week working there, it looks even better on the inside. I’ll be writing more about my experience onboarding with the company over at the Giant Robots Smashing into Other Giant Robots blog soon. But, here’s a key thing that’s excited me. This past Monday, my second day, I started head down on a usability enhancement for an internal tool. On Wednesday, the feature was live in production.

I know there are shops where the first day is pushing something to production, which is legit. There are a lot of shops that don’t have that kind of pipeline worked out, or it takes a lot longer. This was three days for me to write a small but meaningful addition to this product, iterate on it through a pull request code review and ship. I’m really happy about that.

There’s another facet I thought about today on my team’s daily coffee walk. In The Passionate Programmer, Chad Fowler writes:

Legendary jazz guitarist Pat Metheny has a stock piece of advice for young musicians, which is, “Always be the worst guy in every band you’re in.”

A big part of what I’m looking for is being that “worst player” again and learning to play and perform differently and better. It’s a different experience, a little bit strange and it feels pretty good. Onward.

Tool Sharpening: Jan 1, 2015

For some background on what’s going on here, see the first tool sharpening post

Environment + Process tweaks

I added several zsh aliases for some Git actions that are becoming more common for me, when working on feature branches

alias gsl='git stash list'
alias gssv='git stash save'
alias gss='git stash show'
alias gssp='git stash show -p'
alias gsp='git stash pop'

These are particularly useful when I’m in the middle of work on a repository and I want to do anything else, like run a git bisect or examine another branch.

Another use case I have is searching, with find or with ag, then opening resulting files in BBEdit.

A typical case looks like this:

ag -l foo -print0 | xargs bbedit

In this example, any file in the current directory or below containing the term ‘foo’ will be opened in BBEdit. The find version is very similar for cases when I want to open all files with a name containing ‘foo’.

find . -name '2014*' -print | xargs bbedit

Rather than type these commands out every time, I want to type a much shorter command and the search string, like so:

bbf foobar

or

bbg foobar

It would be easiest for me, by experience, to implement each of these in Ruby or Perl. Instead, I chose to implement these as zsh shell functions. I used Erich Smith’s Composure shell library to build the functions. The resulting code looks like this:

# author, about, param, example and group are Composure functions
# ag is the Silver Searcher (brew install ag)
bbf () {
    author 'Nathan L. Walls'
    about 'Function to find files matching a term and open them in BBEdit'
    param '1: Term to search for via `find . -name`'
    example 'bbf 2014*'
    group 'utility'

    find . -name '$*' -print | to_bbedit
}

bbg () {
    author 'Nathan L. Walls'
    about 'Func. to open files containing a term in BBEdit'
    param '1: Term to search for via `ag -l`'
    example 'bbg foo'
    group 'utility'

    ag -l $* -print0 | to_bbedit
}

to_bbedit () {
    author 'Nathan L. Walls'
    about 'Func. to open files in BBEdit through xargs, via a pipe'
    param 'None, implied to come through xargs'
    example 'ls | to_bbedit'
    group 'utility'

    xargs bbedit
}

One other use case I have for this sort of thing doesn’t even require opening files, necessarily, and that’s seeing what files I have that have the word “focus” within them, except spec_helper.rb, in my Ruby projects. This way, I can keep from committing code with focus: true in place and save myself the step of rerunning tests and amending a commit. That looks like this:

alias foc='ag -l focus --ignore spec_helper.rb

Or, at least it did until I thought about it a little more and wanted to make it a function as well. Now, it looks like this, instead:

foc () {
    author 'Nathan L. Walls'
    about "Find errant 'focus: true' statements before committing"
    param 'None'
    example 'foc'
    group 'testing'

    ag -l 'focus: true' --ignore spec_helper.rb
}

Why not use an alias here? Partly because I’m enjoying using Composure and partly because I believe I might make further use of this foc () function elsewhere.

There’s still a bit more I could do with these functions, namely adding some error checking, but these will get the job done for me well enough.

I also:

  • Tweaked BBEdit 11 settings to limit the scope of clippings used for given languages, which keeps me from getting cross-language clipping pollution. In my case, there was a large set of PHP clippings coming up when I was looking for Ruby clippings. And now, I’m not
  • Found a way to Save All open documents in BBEdit, Cmd-Opt-S
  • Added TextExpander shortcuts related to writing Git commit messages
  • Updated my work machine to the dotfiles set-up I highlighted in the previous tool-sharpening entry
  • Created a Cider profile to get my Homebrew set-up into source control
  • Updated Git to address a Mac OS X vulnerability

Project work

  • No project work since the last entry

Skill improvements

See above regarding working with Composure to write shell functions. Overall, I’m finding Composure a really nice little framework for iterating over commands quickly and making them understandable later. It was starting to write these commands and then trying to remember Smith’s presentation at Triangle Ruby Brigade back in August 2014 about Composure that led to my coworker Steve finding Smith’s lightning talk.

Reading and Learning: Dec. 30, 2014

For some background on what’s going on here, see the first tool sharpening post

This is a longer post, simply because of how much time has passed since the previous entry, largely due to end-of-year holiday preparation and celebrations. I hope you enjoyed your holidays with family and friends as I did.

I’m also splitting out what I read, watched and listened to from technical tool sharpening. These are different concerns on different schedules and just as I want to sustain and improve both sets of practices, I don’t want them unnecessarily coupled. So, here’s articles, podcasts and presentations with technical pieces to follow separately.

Articles read

Screencasts, podcasts and presentations

Tool Sharpening: Nov. 23, 2014

For some background on what’s going on here, see the first tool sharpening post

Environment + Process tweaks

I’ve used thoughtbot’s dotfiles repository for years, but I’ve maintained my own fork on GitHub. I’ve also maintained a private sidecar repository for more sensitive things. But, I’ve been out-of-sync with the head of development. Lately, thoughtbot has released rcm which allows for just such a split-brain dotfile set-up. Rather than fight to update my existing set-up, I’ve opened a new repository and ported my existing dotfiles and customizations to a new sidecar repository that fits with rcm’s methodology.

This project took about two hours of focused time for the conversion and gave me an opportunity to rediscover some pieces of my dotfiles that I hadn’t quite fully grasped previously. When it came time, rcm worked perfectly about updating symlinks from the configured repositories into my home directory. Neat tool.

I also:

  • Fixed a Tmuxinator profile for a work project
  • Created a BBEdit project for keeping project specific development notes in a more collected fashion

Project work

I picked up work on my Dayplan bin script/Gem, primarily organizing what has to get done in a step-wise fashion.

Skill improvements

  • Reminding myself of new BBEdit 11 shortcuts and previously worked with Emacs shortcuts that are available in BBEdit

Articles read

  • “The Sixth Stage of Grief Is Retro-computing”, by Paul Ford
    • This piece has been recommended by a lot of folks over the last few weeks and I’m adding my recommendation to the pile
  • “Web Applications and Security”, by Alan Cox
  • “The unexpected costs of third-party login”, by Taylor Hughes

    • Just what it says on the tin. There are some substantial tradeoffs to using Google, Twitter or Facebook accounts as login mechanisms that aren’t readily apparent when a product team decides to shortcut account creation. One point I found particularly interesting was this:

      As it turns out, supporting multiple sign-in options adds a tremendous amount of complexity. Instead of an interface where a user can only do one thing — even if it means filling out a tedious form — people have to stop and think about options.

      This leads to another unexpected side-effect: When logging back in, lots of people forget how they signed up for your service in the first place, and they end up trying the wrong method.

      Worse, long-lived mobile sessions exacerbate the issue. When users log in again months later, it’s like rolling the dice.

      This results in support emails from users who are very confused about why all their content is missing after upgrading phones — or users wondering why, when they login on the web site, none of their stuff appears.

  • “Tail Call Optimization in Ruby”, by Nithin Bekal

  • “Rust and Go”, by Adam Jacob

  • “A Five-stage Model Of the Mental Activities Involved in Directed Skill Acquisition”, by Stuart E. Dreyfus and Hubert L. Dreyfus

    • This is the original “Dreyfus Model of Skill Acquisition” paper and very accessible
  • Corey Haines, “Short-lived Branches”

    • Haines explores the constraint of finishing a feature on a branch in a day or deleting it and starting over the next
  • “How to Read an Academic Article”, by Peter Klein

    • With the growth of groups like Papers We Love, it’s helpful to have an idea on how to approach reading academically focused material
    • There’s more info at Papers We Love’s Boston chapter with an upcoming meeting

Screencasts, podcasts and presentations

  • Attended Brandon Mathis' Triangle Ruby Brigade presentation, “Dive into Ruby”
    • A nifty, REPL-driven question and answer presentation for folks new to Ruby
  • Organized and attended Henry Petroski’s Triangle DevOps presentation, “Success and Failure in Engineering: A Paradoxical Relationship”
    • I’ve been a huge fan of Dr. Petroski and I asked him back in January, via note I sent to his department at Duke University, if he would be willing to speak to the group. He was and the talk he delivered this past week was absolutely everything I hoped it would be
    • The talk was recorded by our hosts at Bronto Software. Give it a look.
  • Listened to Is TDD Dead: Ep. 3: “Feedback and QA”
  • Listened to Is TDD Dead: Ep. 4 + 5: “Costs of Testing” and “Answering Questions”
    • These two episodes finished out the series. It is evident that each of the participants has a great deal of respect for the other two
    • I’m far closer to Martin Fowler and Kent Beck’s positions on the value of testing than I am David Heinemeier Hansson’s
    • Despite being further from DHH’s position, I leave the series with a better understanding of his perspective
  • Listened to Accidental Tech Podcast Ep. 88: “Standing on Opposite Sides of the Gym”
  • Listened to Accidental Tech Podcast Ep. 89: “DeLorean + McLaren”
  • Listened to Giant Robots Smashing Into Other Giant Robots Ep. 121: “Prolificness (Allison House)”
    • Something House mentioned during the podcast was the notion of a second shift of personal projects, e.g. a 20-minute portrait painting where the painter has to focus on what’s critical
    • The key, it sounds like of second shift personal work is making it consistent and sustainable
    • This is something I aspire to, but still find myself struggling with
  • Listened to Bikeshed: Ep. 1: “Sandi & Derek’s Rules”
  • Listened to Back to Work Ep. 193: “Disappointment Delivery Mechanism”
  • Listened to Back to Work Ep. 194: “The Company of a Clown” Listened to Ruby Rogues Ep. 179: “Accountability and Diversity with Meagan Waller”
  • Listened to Ruby Rogues Ep. 180: “Barriers to New Developers with Kinsey Ann Durham”
    • I can’t think of a bad episode of Ruby Rogues, but these two are exceptionally good ones – windows into experiences I can’t have (being a female developer) or haven’t had in a long time (being a new developer). I highly recommend giving these both a thorough listen

Programming note

First, I can explicitly state the next entry will be in December, likely Dec. 7. Second, I’m entertaining the idea of breaking this larger post into smaller components. Once a week for all of this feels a little thin and two weeks starts to feel a little much. I’m thinking the articles and podcast/presentation sections are both getting a little long and may benefit from separate publication weekly with my project work, environment tweaks and skill improvements happening more on a biweekly basis. I’m not set on that, but I think I’m going to experiment with it.

Tool Sharpening: Nov. 9, 2014

For some background on what’s going on here, see the first tool sharpening post

This week, there’s not a lot with regard to more than podcasts or articles read. On one hand, I’m not happy in hindsight with not having written much code. But, I have to balance that against the fact that I did more reading and, honestly, that’s what the week felt like.

Environment + Process tweaks

  • Added a few GMail filters for mailing lists to help improve inbox sanity

Project work

Somehow, the week was busier than expected and somehow, not code-focused, so the pieces I wanted to get to, I didn’t. I don’t like that outcome.

Skill improvements

Nothing particularly of note here, this week.

Articles read

Alright, here’s where most of my post-work tool-sharpening time went. There were several interesting pieces.

  • “The Road to Ember 2.0” by Tom Dale
    • A polite, but audible, shot across the bow of Angular JS and the notion of having to rewrite apps to keep up with framework changes as being an acceptable course of action
  • “AngularJS: The Bad Parts”, by Lars Eidnes, who throws down early against AngularJS

    • Quote:

    Popularity wise, Angular is beating the shit out of the other frameworks. I spent most of last year working on a large project built on AngularJS, and I’ve gotten to know the framework in some depth. Through this work I have learned that Angular is built around some really bad ideas that make it a pain to work with, and that we need to come up with something better. Whatever the reason is for Angulars popularity, it isn’t that it’s a great framework. - The polemic against Angular is good. Stick around for the conclusion, too.

  • “Rebuilding the Shopify Admin: Improving Developer Productivity by Deleting 28,000 lines of JavaScript”

    • A possible outrider indicating a move away from thick front-end web applications back to server-side focused applications

Altogether, these first three pieces point to a trend I won’t pretend is anyway new – this is where the women and men programming in the 70s and 80s shake their heads and mutter, “kids” – but one that I’ve noticed over the last couple of years is that as an industry, we are so eager to think of something new and shiny as a self-evidently worth replacement for whatever came before it. We pick frameworks or languages because of where everyone else is going, but not stopping to look at what’s there before ditching something we know.

There’s a lot more nuance and complexity to this than I can think through and write right now, but I liked these three pieces because each of them, to a degree calls out practices I’ve seen recently that have left a bad taste in my mouth.

Screencasts, podcasts and presentations

  • Listened to Giant Robots Smashing Into Other Giant Robots Ep. 119: “Create Value or Create Technology? (Pete Hunt)”
  • Listened to Back to Work Ep. 192: “Party City Trophies”
    • Dan and Merlin have a great episode about finding how to motivate their kids without backstopping their parenting with fear. Powerful and personal
  • Listened to Is TDD Dead?: Ep. 2: “Test-induced design damage”
    • David Heinemeier Hansson expands on why he thinks TDD leads to damaged repository. I thought Kent Beck did quite well in pointing out that TDD doesn’t make you do anything. My opinion is closer to Beck’s so far and I am very much enjoying hear him express a depth to his point of view that is worth listening to, whether or not you agree with him

← Previous