camdez.com

Rule #1: There are no rules.

2017 Reading List

| Comments

Last year I tried out making a reading list in January, to keep myself reading at an acceptable pace, and to put a bit more foresight into what I would be reading. This worked out pretty well. Despite finishing a couple of my 2016 books in the first days of 2017, I largely stuck to my schedule, and I finished everything on my list, including a few rather lengthy items. I actually didn’t read a whole lot more than I had listed (to my surprise), which makes me even more confident that this is a good idea, since it sets a minimum reading curriculum.

Again this year, I’ve tried to establish some common themes to allow for comparative reading and amass some knowledge of a field. The stronger themes are decision-making (four books) and creativity (four books), and the remaining four books are loosely centered on self-improvement, though that’s more of a coincidence than a plan.

Curation Is Creation

| Comments

Last Black Friday I posted to Facebook:

I’m abstaining from buying anything today in protest of excessive consumerism. Make something instead!

And got a rather curious reply from a friend:

I wish I could make things

I mulled that over for quite a while. I struggled to put myself in the commenter’s shoes. It’s wildly foreign to me.

In my head, clearly creation is for everyone. It’s not the domain of some privileged class of individuals—it’s an essential act of being human. Everyone should—and can!—create. But I kept tugging at the thread because of a nagging suspicion that perhaps lots of people feel this way.

No, Seriously, It’s Naming

| Comments

I just read David Bryant Copeland’s post It’s not Naming That’s Hard—It’s Types which he wrote in response to Katrina Owen’s What’s in a Name? Anti-Patterns to a Hard Problem and I feel compelled to say a few words. Katrina’s post provides some suggestions around the perennial developer challenge of naming things in code. Along the way she asserts that including the type of a variable in its name is typically an antipattern, and “type information is just not that compelling”—something David took great exception to.

David argues that the actual problem is we don’t have enough types: “types are a better way to solve the problems Katrina identifies in her post.”

He then proceeds to turn Katrina’s perfectly reasonable bit of code…

1
2
3
4
5
6
7
8
9
def anagrams(subject, candidates)
  candidates.each do |candidate|
    subject != candidate && same_alphagram?(subject, candidate)
  end
end

def same_alphagram?(subject, candidate)
  # ... (not provided, but I want to offer a fair comparison of length)
end

…into this…

Reading Notes: Just Fucking Ship

| Comments

Whenever you look around, you know what you should be doing: creating and launching and selling a product, bootstrapping a business on the side. You’re smart. You’re capable. You’ve got the skills to make stuff […] why can’t you just make this happen? […] We’ll teach you 21 principles for getting off your butt and finally shipping. (official site)

Part of my 2016 reading list.

This is soup to nuts guide to the human aspects of shipping a side project. It’s not going to teach you how to design a logo or a code a website, but if what’s holding you back from completing your dream is lack of confidence, disorganization, over-ambition, etc., then this could be the book for you.

There’s nothing tremendously groundbreaking here, but it’s compact and won’t waste your time (as I’ve come to expect from Amy Hoy).

Reading Notes: The Meditations of Marcus Aurelius

| Comments

Meditations…is a series of personal writings by Marcus Aurelius, Roman Emperor from 161 to 180 AD, recording his private notes to himself and ideas on Stoic philosophy. Marcus Aurelius wrote the 12 books of the Meditations…as a source for his own guidance and self-improvement. (Wikipedia)

Part of my 2016 reading list.

Definitely a worthwhile read. I read the (recent) Hays translation as I heard it continually recommended. These are private notes on life from a great man, and one of the great charms of this book is that it’s not dressed up in hopes of impressing anyone—it’s practical and direct. He probably never expected anyone else to read it.

2016 Reading List

| Comments

2015 was a haphazard reading year for me, with a number of partially-read books at the beginning of the year, squeezing in a few pages in my tent while roadtripping across the western U.S., and then finally powering through a few more books once life settled down a bit. Eleven books finished in total, assuming I’m not missing anything.

This year I’m going to try being a bit more structured (in the spirit of Mark Zuckerberg), and lay out a schedule of what I will definitely be reading. With my current workload that’s going to be a modest one-book-per-month pace, but additional reading is of course welcome. A schedule will allow me to clear my plate of a few lingering items, establish some higher-level reading themes, and have some idea of when I’ll actually get to one book or another.

Project: Honeybadger for Clojure

| Comments

TLDR: I’ve just released a pair of libraries which I believe constitute the best way to use the Honeybadger exception reporting service from Clojure—camdez/honeybadger and camdez/ring-honeybadger.

I’ve been using weavejester’s ring-honeybadger in my projects, and while it has served me well, I end up rewriting the Ring integration every time because it’s not particularly open for extension. I also feel that Honeybadger has a lot of utility beyond just reporting exceptions from web servers, and towards that end I wanted to write one library that encapsulates all of the features of Honeybadger, atop which something like a Ring reporter could be written. I’ve tried to consider what the appropriate extension points are, and how to make common things easy.

Practical Data Coercion With Prismatic/schema

| Comments

If you follow me on Twitter, you probably know I’m a big fan of Prismatic’s schema library, which gives us a convenient way to validate and enforce the format of data in our Clojure applications. I use schema extensively both to provide some of the comfort / confirmation of a static type system, and to enforce run-time contracts for data coming off the wire.

But a problem quickly arises when we’re enforcing contracts over data drawn from an external format like JSON: the range of types available in JSON is limited compared to what we’re used to in Clojure, and might not include some of the types we’ve used in our schemas, leaving our schemas impossible to satisfy. Note that I’m not necessarily talking about anything exotic—simple things like sets, keywords, and dates are missing. The situation is even worse if we’re talking about validating command line parameters, where everything is a string regardless of if it logically represents a number, an enumeration value, or a URL.

What are we to do? Try to walk this data of unknown format, which is perhaps nested with optional components, transforming certain bits, and then running the result through our schema validation? That sounds ugly. And what do those error messages look like when it doesn’t match? Or we could validate that our (say) “date” parameters are present and are strings in a format that looks like we could parse it, then transform the data (which is at least in a known format now), and then validate it again? Obviously that’s less than ideal. And we’re going to end up with a proliferation of schemas which differ only in predictable ways—e.g. “params come in as a hash of two date-like strings, then get transformed to a hash of two dates”.