hardscrabble 🍫

By Max Jacobson

Psst. Check out my RubyConf 2017 talk, There are no rules in Ruby.

blog posts

all the thoughts that went through my head while trying to pass the first test in the test suite of a warm up exercise this morning before coffee and then again this evening after painkillers

03 Jul 2013

Recently at school we’ve been doing code exercises to warm up in the morning. We’re given contained problems to solve with code. Problems that would be possible to solve without code but tedious or prohibitively time-consuming. Sometimes we move on to lecture before I can solve one and it haunts me all day.

Here’s this morning’s:

Palindrome Product

A palindromic number reads the same both ways.

The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 x 99.

Write a program that can detect palindrome products in a given range.

The specifics of what this means were ostensibly made more clear by a provided test-suite.

I’ve done a problem like this before at a coding meetup and I remembered how I’d wrestled with it for minutes and got it working and then seen someone else’s impossibly elegant solution and felt inspired.

Mine was probably something like this:

def is_palindrome?(num)
  digits = num.to_s.split("")
  i = 0
  while i < digits.length
    if digits[i] != digits[-i-1]
      return false
    end
    i += 1
  end
  return true
end

ugh

And hers was something like this:

def is_palindrome?(num)
  num.to_s == num.to_s.reverse
end

And I was just like oh.

So this morning I had a moment of thinking I already knew the hard part of this problem, and then I looked at the tests. Here’s the first one:

test 'largest_palindrome_from_single_digit_factors' do
  palindromes = Palindromes.new(max_factor: 9)
  palindromes.generate
  largest = palindromes.largest
  assert_equal 9, largest.value
  assert [[[3, 3], [1, 9]], [[1, 9], [3, 3]]].include? largest.factors
end

first test

Oh there’s a lot more going on there.

But that’s fine, I think, I’ll make a Palindromes class, give it a few methods, that’s fine, let’s do it. So I started with something like this:

class Palindromes
  def initialize(options)
    max = options[:max_factor]
    # then I decided the range would begin at 1 mainly because it has to start somewhere and the test's assertion seemed to suggest 1
    min = 1
    @range = min..max

    # At this point I sort of paused to think about what to do next and Kristen noticed I stopped typing and said something about how I should host a show called "Max Factor" and I laughed.
  end

  # this felt as good a place as any to write that ace method I had in my back pocket
  def is_palindrome?(num)
    num.to_s == num.to_s.reverse
  end

  # then I was like uhh I guess I need a generate method
  # what does that even mean though
  def generate
    @range.each do |num1|
      @range.each do |num2|
        # what if I like... iterate over the range twice nested like this
        # this looks too ugly to be right but I think maybe...
        if is_palindrome?(num1 * num2)
          [num1, num2] # I know I have to do something with this array
          num1 * num2  # And also their product maybe?
          # but what
        end
      end
    end
  end
end

first draft

At this point something about the test bubbled to the surface of my mind.

largest = palindromes.largest
assert_equal 9, largest.value

wait what?

Wait, what the what is the largest method returning that it has a value method?

Damnit Jeff do we have to create another class?

OK fine I guess palindrome factors are a sufficiently interesting thing that they should be their own class. I kind of reached a point in the generate method where I had some data I didn’t know what to do with, and that makes some sense as a place to put it, so I started rewriting… and ran out of time.

I’m going to finish it now, I have to. It’s very late. I used to stay up this late. Jeez.

class PalindromeFactors
  attr_accessor :value, :factors
  def initialize(num1, num2)
    @value = num1 * num2
    @factors = [num1, num2]
  end
  # that should maybe be enough for now?
  # the value will be a palindrome
end

class Palindromes
  def initialize(options)
    max = options[:max_factor]
    min = 1
    @range = min..max
    # so let's keep track of the factors whose product is a palindrome
    @palindrome_factors = []
  end

  def is_palindrome?(num)
    num.to_s == num.to_s.reverse
  end

  def generate
    @range.each do |num1|
      @range.each do |num2|
        if is_palindrome?(num1 * num2)
          # create the new object and shovel it into the array
          @palindrome_factors << PalindromeFactors.new(num1, num2)
        end
      end
    end
  end

  def largest
    @palindrome_factors.sort_by{ |pf| pf.value }.last
  end

end

second draft

Up until this point, running the tests hasn’t felt worth doing, because I didn’t even have the methods it’s trying to call. But now I do. And maybe it’ll even pass.

It doesn’t make them pass.

Before I knew about proper test-driven development, I did a sort of shake-and-bake version where I manually tested things, and my favorite tool for that is CodeRunner which lets me just run little bits of code and see what happens. Kind of like irb/pry but with a GUI. So I copy my code into there without the tests and add this:

palindromes = Palindromes.new(max_factor: 9)
palindromes.generate
largest = palindromes.largest
puts palindromes.inspect

poking at it

And this is what it printed:

#<Palindromes:0x007f902a10a100 @range=1..9, @palindrome_factors=[#<PalindromeFactors:0x007f902a10a010 @value=1, @factors=[1, 1]>, #<PalindromeFactors:0x007f902a109f48 @value=2, @factors=[1, 2]>, #<PalindromeFactors:0x007f902a109e80 @value=3, @factors=[1, 3]>, #<PalindromeFactors:0x007f902a109db8 @value=4, @factors=[1, 4]>, #<PalindromeFactors:0x007f902a109cf0 @value=5, @factors=[1, 5]>, #<PalindromeFactors:0x007f902a109c28 @value=6, @factors=[1, 6]>, #<PalindromeFactors:0x007f902a109b60 @value=7, @factors=[1, 7]>, #<PalindromeFactors:0x007f902a109a98 @value=8, @factors=[1, 8]>, #<PalindromeFactors:0x007f902a1099d0 @value=9, @factors=[1, 9]>, #<PalindromeFactors:0x007f902a109908 @value=2, @factors=[2, 1]>, #<PalindromeFactors:0x007f902a109840 @value=4, @factors=[2, 2]>, #<PalindromeFactors:0x007f902a109778 @value=6, @factors=[2, 3]>, #<PalindromeFactors:0x007f902a1096b0 @value=8, @factors=[2, 4]>, #<PalindromeFactors:0x007f902a109390 @value=3, @factors=[3, 1]>, #<PalindromeFactors:0x007f902a1092c8 @value=6, @factors=[3, 2]>, #<PalindromeFactors:0x007f902a109200 @value=9, @factors=[3, 3]>, #<PalindromeFactors:0x007f902a04c100 @value=4, @factors=[4, 1]>, #<PalindromeFactors:0x007f902a04be08 @value=8, @factors=[4, 2]>, #<PalindromeFactors:0x007f902a04b098 @value=5, @factors=[5, 1]>, #<PalindromeFactors:0x007f902a04a210 @value=6, @factors=[6, 1]>, #<PalindromeFactors:0x007f902a0494a0 @value=7, @factors=[7, 1]>, #<PalindromeFactors:0x007f902a048708 @value=8, @factors=[8, 1]>, #<PalindromeFactors:0x007f902a112cb0 @value=9, @factors=[9, 1]>]>

whoa nelly

I’m always surprised by the dumbest things, but that seems really long to me. That’s not even every permutation of 1..9, it’s just the ones whose product is a palindrome.

Even though it surprised me, I still don’t really see why it’s wrong. So I take a look at the first assertion and try to test it

# the assertion:
# largest = palindromes.largest
# assert_equal 9, largest.value
puts largest.value

testing first assertion

And it printed: 9. Hey! That probably passed! Shouldn’t it turn like half green or something?

OK fun’s over let’s look at the next test.

palindromes = Palindromes.new(max_factor: 9)
palindromes.generate
largest = palindromes.largest
# assert [[[3, 3], [1, 9]], [[1, 9], [3, 3]]].include? largest.factors
puts largest.factors.inspect

testing second assertion

And it printed: [9, 1].

For a moment my nose flares because I think this is a bad test and it’s not my fault. Of course it’s not my fault my largest method returns the two digits in one order and the test is expecting them in the other order! The way multiplication works, the order doesn’t matter! It should just include [9,1] in that list so my answer will be right! I want to just edit my answer into to the list of acceptable answers.

I want to be clear that at the time of the writing of this sentence I still don’t really know what’s wrong with it but I kind of have a hunch. I’m noticing there are actually way more brackets in that array than I was mentally doing anything with. It’s not an array of arrays, it’s an array of arrays of arrays! But why? I’m going to just look at it for a moment here:

[
  [
    [3, 3],
    [1, 9]
  ],
  [
    [1, 9],
    [3, 3]
  ]
]

what’s the deal with arrays

So maybe the order of nine and one matters later, but it’s not why I failed this test.

The test asserts that this array includes the largest palindrome’s factors. The largest value is nine – I got that part! – but there are two in-range pairs of numbers that multiply to form nine, and I’m not currently doing anything to group those together. The test is accounting for those two sets of pairs to be grouped in either order, but it wants both. Okay. Now I know.

I made some changes that felt right. I didn’t really think a lot so much as I just vibed out to the new A Great Big Pile Of Leaves album (which has played through maybe three times in full as I write this post) and typed stuff.

class PalindromeFactors
  attr_accessor :value, :factors
  def initialize(num1, num2)
    @value = num1 * num2
    # let's wrap our factors array in an envelope array in case there are multiple ways to arrive at this palindrome
    @factors = [[num1, num2]]
  end

  # and make a method to allow these objects to be updated post hoc
  def add_factor(num1, num2)
    @factors << [num1, num2]
  end

end

class Palindromes
  def initialize(options)
    max = options[:max_factor]
    min = 1
    @range = min..max
    # so let's keep track of the factors whose product is a palindrome
    @palindrome_factors = []
  end

  def is_palindrome?(num)
    num.to_s == num.to_s.reverse
  end

  def generate
    @range.each do |num1|
      @range.each do |num2|
        # let's stash this product in a variable because we'll be using it a few times
        product = num1 * num2
        if is_palindrome?(product)
          # let's check if we've already found this palindrome
          already_found = @palindrome_factors.find{ |pf| pf.value == product }
          if already_found
            already_found.add_factor(num1, num2)
          else
            @palindrome_factors << PalindromeFactors.new(num1, num2)
          end
        end
      end
    end
  end

  def largest
    @palindrome_factors.sort_by{ |pf| pf.value }.last
  end

end

third draft

Allow me to be absolutely clear: this still does not pass the tests but I’m starting to feel a momentum and a full glass of milk happiness in my head because mysteries are unraveling before me.

When I go back to CodeRunner, where I used to see merely [9, 1] I now see: [[1, 9], [3, 3], [9, 1]] and I know what to do.

I change lines 10-13 of the previous example to:

def add_factor(num1, num2)
  @factors << [num1, num2] unless @factors.include? [num2, num1]
end

aha

and run the tests and it passes and I should be weeping happily right now.

After passing the first test it only takes about 30 seconds to get the rest to pass. Here’s my final solution on gist. It’s out of the scope of this post.


Later in the day, Carlos remarked that he sometimes leaves his body while doing yoga. I asked if the same is true for programming but I think I already knew how I felt about that.

I find problems like this very satisfying in that same disassociative, mind-clearing way. When I first start, my mind is moving too fast and I make too many assumptions and just start doing things and that’s probably fine because that’s how I find out what shape it is. I’m reminded of this Steven King quote on writing from On Writing (via):

Stories are found things, like fossils in the ground. . . . Stories aren’t souvenir tee-shirts or GameBoys. Stories are relics, part of an undiscovered pre-existing world. The writer’s job is to use the tools in his or her toolbox to get as much of each one out of the ground intact as possible. Sometimes the fossil you uncover is small; a seashell. Sometimes it’s enormous, a Tyrannosaurus Rex with all those gigantic ribs and grinning teeth. Either way, short story or thousand-page whopper of a novel, the techniques of excavation remain basically the same.

No matter how good you are, no matter how much experience you have, it’s probably impossible to get the entire fossil out of the ground without a few breaks and losses. To get even most of it, the shovel must give way to more delicate tools: airhose, palm-pick, perhaps even a toothbrush.

Right?? What a beautiful, humble reframing of what makes great creative work: no, you’re not some genius coming up with profound, original ideas; you’re just digging, and gently, and hoping that if you just keep trying stuff, you’ll find something.

blogs... how do they work?

18 Jun 2013

I’ve been using this Octopress blog for a couple weeks and I’m compelled to figure out how it works and came to be. Let’s spelunk now.

In October 2008, in a blog post called “Blogging Like a Hacker” Tom Preston-Werner (GitHub co-founder) announced Jekyll, a new website generator for his personal blog. He sought to answer the question: “What would happen if I approached blogging from a software development perspective? What would that look like?” Here’s the wayback machine archive of that post which is remarkable mainly for looking pretty much the same.

A scant two months later, in December 2008, GitHub announced Pages, a new way to host static sites on GitHub, each of which is processed by Jekyll, regardless of whether the programmer took advantage of its features. (Sidebar: it would be fun to work at a company where I could have an idea for a personal project and then find a home for it in a place that others will find and get use from it.)

At that time, Jekyll was at v0.2.1. In order to time travel and try that version of Jekyll on my local machine I ran these commands:

git clone https://github.com/mojombo/jekyll.git
cd jekyll
git checkout v0.2.1
gem build jekyll.gemspec
gem install jekyll-0.2.1.gem
jekyll --version

And got a bunch of error messages. Ok. I don’t know what’s up with these. Let me fast-forward to April 2009 when they announced that GitHub pages was upgraded to use Jekyll v0.5.0. The marquee feature of v0.5.0 is a configuration file.

git checkout v0.5.0
gem build jekyll.gemspec
gem install jekyll-0.5.0.gem
jekyll --version
#=> Jekyll 0.5.0

OK nice. I’m close to arriving at a point. Imagine being a programmer wanting to start a blog at this point in time and wanting to write in Markdown or Textile and wanting to manage your source files in Git and compile a static site and deploy it on GitHub and encountering this upon running jekyll --help:


Jekyll is a blog-aware, static site generator.

Basic Command Line Usage:
  jekyll                                                   # . -> ./_site
  jekyll <path to write generated site>                    # . -> <path>
  jekyll <path to source> <path to write generated site>   # <path> -> <path>

  Configuration is read from '<source>/_config.yaml' but can be overriden
  using the following options:

        --auto                       Auto-regenerate
        --no-auto                    No auto-regenerate
        --server [PORT]              Start web server (default port 4000)
        --lsi                        Use LSI for better related posts
        --pygments                   Use pygments to highlight code
        --rdiscount                  Use rdiscount gem for Markdown
        --permalink [TYPE]           Use 'date' (default) for YYYY/MM/DD
        --version                    Display current version

Alright, cool. Yeah. Ok. Wait where do I start?

Real blog agenda confession: I was planning to get stumped here to make a point but actually the README pretty clearly recommends cloning a “proto-site repo” at https://github.com/mojombo/tpw and going from there so that’s what I’ll do now and see where this takes me.

git clone https://github.com/mojombo/tpw.git
cd tpw
git checkout b107ffb6e44fe4f2398b219e254426d3ec302142
jekyll --server

(That SHA is the last commit to that repo as of April 2009 and I feel like a time traveler with secret codez).

What this gives you is a blog that looks very much like Preston-Werner’s and a pattern to follow: replace his posts with your posts; replace his name with your name; commit and push. Now you have a stark, white blog just like that cool guy.

Later in 2009, in October, Brandon Mathis released Octopress, a framework for Jekyll. In what must be an homage to that original blog post, its tagline is “A blogging framework for hackers”. Since then he’s built an ecosystem for plugins and themes around this framework. Where Jekyll is “blog aware”, Octopress is blog obsessed. Where Jekyll gives you just enough to get started, Octopress gives you a super sturdy, robust design and toolset.

Some key differences between Octopress and pure Jekyll

  • When deploying an Octopress blog to GitHub Pages, you compile the static files before pushing; when deploying a pure Jekyll blog to GitHub Pages, you push the uncompiled source files, with unrendered markup files and templates, and it compiles the assets upon receiving the push. If you want to use plugins, Octopress is a better choice because their effects can be wraught during the compilation but not in the post-receive hook (on GitHub anyway; you can set up your own server if you need all that).
  • That also means you only need one branch for a pure Jekyll blog, where you need two (“source” and “master”) for Octopress.
  • It also means the commit log on your master branch is full of auto-generated, non-semantic commit messages (boo right?)
  • There are way more source files in an Octopress blog, which can feel somewhat constrictive, at least to this young blogger.
  • Octopress’s rake preview command watches for changes, including those made to the sass files, and compiles those into CSS. It would be cool if it compiled CoffeeScript too.
  • Octopress has this kind of confusing relationship with Git branches where its root directory stays on branch “source” and is updated by the blogger, and contains a directory called _deploy which contains a second instance of the same repo, which is meant to stay on branch “master” and be auto-generated by the framework. It’s a clever solution to the situation constraints but not immediately intuitive or adequately explained (including by me just now, I’m sure).

Because Jekyll is distributed as a gem and has a simpler, smaller file structure and a normal git repo, I’m tempted to suggest it’s a better place to start for someone interested in getting their feet wet with this kind of “hacker” blogging. It’s easy to discard Preston-Werner’s theme and start from scratch, and if your site is ugly then, as we’ve learned, you’re in good hacker company.

This is probably more true than ever since, in May 2013, just last month, Jekyll 1.0 was released and with it a magical, long-overdue command: jekyll new which – you guessed it – instantiates a plain white blog for you on your filesystem.

Also new is http://jekyllrb.com, some great (and beautifully designed) documentation to reference as you extend your site.

what even is jekyll

The Jekyll program itself is written in Ruby, but you don’t need to know Ruby to work with Jekyll. You just need to be okay with the idea of Ruby code generating your blog. In fact, if you go in knowing some Ruby, you might find yourself confused by some things like I was.

Jekyll looks at each markup file (HTML, Markdown, Textile) in your project and looks at the file extension to know how to convert to HTML, if it needs to. It’s smart enough to know that some people use .md and others use .markdown and to just be chill about it. It reads the “YAML frontmatter” to look for instructions for what to do with these files, like if it should look like a post, with the date and maybe comments or if it’s just some generic page. You can stash arbitrary values in their to use in your layouts too, like putting mood: happy at the top of fun posts and then referencing page.mood in your posts layout.

So let’s talk about that templating system briefly. Knowing Jekyll is a Ruby project, and having dabbled with Ruby web development, I made the mistake of assuming Jekyll would follow Ruby conventions that I was familiar with (something like Haml or ERB or Slim), but it kind of doesn’t. What it uses is Liquid, a templating system developed by Shopify. Like Jekyll, it’s written in Ruby and distributed as a gem, so it bundles along well. Once I adjusted my expectations, I found it easy to work with. When you initialize a new Jekyll site (with jekyll new my_great_blog), it gives you this index.html file to be your barebones homepage:

(note: I think I have to use a GitHub Gist to host that code snippet because if I embed it in this post, Jekyll will interpet the Liquid tags)

Alright so clearly it’s mostly HTML, and the file extension is .html, but there’s a lot in there that’s not valid HTML and would confuse your browser if opened directly. Which is fine, because that’s not what you do. This is what a Liquid template looks like. If you’re looking for Ruby, you’ll be rebuffed by this. I have no idea where endfor comes from and the double curly braces and dot notation are very JavaScript-y. So learn to love Liquid, I guess.

This file is not a complete web page. It has no doctype or <head> or <body> tags. It’s a partial. The file that has the rest of it is in _layouts/default.html and the line layout: default in this file tells Jekyll to compile this, then insert it into that. You can define more layouts but you may not have to. The other layout that comes with Jekyll is _layouts/post.html which is actually also a partial. When you write a blog post, it has layout: post in the YAML, so the compiled post is sent to _layouts/post.html, which has layout: default in the header, so it does a few things then passes the ball along to its final stop. It’s like a cheap Russian nesting doll with only three dolls.

unspelunk

Honestly both are great. Octopress feels like rocket powered training wheels, but that’s a fun visual so