Flying Machine Studios

Abstract Mathematics and Programming

2012-02-23T11:56:17Z

Abstract Mathematics and Programming

If you’ve been alive long enough to develop language comprehension, you’ve probably heard that most people don’t like math. The usual complaint is that it’s just a bunch of formulas disconnected from everything and that you have to memorize in order to finish school.

My opinion is that the poor souls who hate math have never been exposed to the abstract method. This is explained by Timothy Gowers in Mathematics: a Very Short Introduction :

What is the black king in chess? This is a strange question, and the most satisfactory way to deal with it seems to be to sidestep it slightly. What more can one do than point to a chessboard and explain the rules of the game, perhaps paying paprticular attention to the black king as one does so? What matters about the black king is not its existence, or its intrinsic nature, but the role that it plays in the game.

The abstract method in mathematics, as it is sometimes called, is what results when one takes a similar attitude to mathematical objects.

This description does not paint a clear, concrete picture of the abstract method, but I hope it serves to at least rouse your curiosity, and that your curiosity rouses you to read more at the link above. By exploring mathematics from the point of view of the abstract method, you’ll come to see math in a different way.

You’ll begin to learn how it’s possible for some people to take pleasure in reading proofs. Hopefully, you yourself will experience the delight and surprise that comes from treating math as a process of defining mathematical objects in terms of their interactions, and seeing what results from the logical application of mathematical rules. It’s like solving a crossword or sudoku puzzle, only, like, a million times cooler.

Besides its intrinsic value, I think that learning abstract math will make it easier to learn how to program. By learning this approach to math, it makes it easier to disassociate programming symbols from their intuitive, english-y or math-y meetings. For example, “function” is a keyword in many programming languages, but it differs dramatically from the English meaning of “function” and subtly from the functions we’re used to in algebra. Learning to see programming symbols as merely symbols subject to the rules of the programming language is useful.

I also believe that learning abstract math makes your thinking more flexible, but it’s hard for me to describe how. You just see the world differently.

The above book by Timothy Gowers seems like a good introduction. Personally I was introduced to the ideas through Godel, Escher, Bach: an Eternal Golden Braid and Godel’s Proof . Both books are a true joy. The first can take awhile to get through, but the second is a considerably quicker read. They both demonstrate the beauty and delight within mathematics.

I regret that I don’t have the time to provide some concrete examples of how learning this stuff is fun and could possibly help you learn programming. However, I hope that writing about my own experiences might motivate folks to go out there and learn themselves some real math.

Machine-Aided Introspection

2012-02-22T09:23:17Z

Machine-Aided Introspection

What if you had a machine that provided statistics on every part of your life? You could see how many times you’ve heard a song (not just listened to it on X device), how often you drink coffee, the increase in frequency to trips to your favorite restaurant.

More interestingly — what if this machine monitored your internal state and correlated it with external events? I mean, what would it be like to have a machine that confirmed that yes, you actually do think that your boss (or neighbor, or friend, or whoever) is actually an asshole? Such a machine could reveal that every time your visual (or auditory or olfactory) system recognizes him, your cortisol levels start rising. Or, what if the device automatically revealed that your feelings of discomfort with a colleague are triggered by some long-buried memory triggered by her glasses rather than anything she’s actually said or done?

I find these questions intriguing because I believe that such a device is possible, and possibly inevitable. Biofeedback devices already exist to help people control their anger or prevent migraines. In general, it takes hard work to become aware of your emotional state and to manage it. It’d be interesting to see the effects of machine-aided introspection. What would happen if you made use of a device that could instantly let you know all the pieces about yourself that you wish you knew? Or that you don’t want yourself to know?

An Exhaustive Explanation of Minimax, a Staple AI Algorithm

2012-01-11T02:42:00Z

An Exhaustive Explanation of Minimax, a Staple AI Algorithm

Overview

The minimax algorithm is used to determine which moves a computer player makes in games like tic-tac-toe, checkers, othello, and chess. These kinds of games are called games of perfect information because it is possible to see all possible moves. A game like scrabble is not a game of perfect information because there’s no way to predict your opponent’s moves because you can’t see his hand.

You can think of the algorithm as similar to the human thought process of saying, “OK, if I make this move, then my opponent can only make two moves, and each of those would let me win. So this is the right move to make.”

The rest of the article explains how to represent possible moves and evaluate them. An example command-line tic-tac-toe game using Ruby is given.

Representing Moves with the Game Tree Data Structure

Here’s an example of a Game Tree for tic-tac-toe:

Note that this isn’t a full game tree. A full game tree has hundreds of thousands of game states, so that’s uh… not really possible to include in an image. Some of the discrepancies between the example above and a fully-drawn game tree include:

The first Game State would show nine moves descending from it, one for each of the empty spaces on its board
Similarly, the next level of Game States would show eight moves descending from them, and so on for each Game State

Representing the game as a game tree allows the computer to evaluate each of its current possible moves by determining whether it will ultimately result in a win or a loss. We’ll get into how the computer determines this in the next section, Ranking. Before that, though, we need to clearly define the central concepts defining a Game Tree:

The board state. In this case, where the X’s and O’s are.
The current player – the player who will be making the next move.
The next available moves. For humans, a move involves placing a game token. For the computer, it’s a matter of selecting the next game state. As humans, we never say, “I’ve selected the next game state”, but it’s useful to think of it that way in order to understand the minimax algorithm.
The game state – the grouping of the three previous concepts.

So, a Game Tree is a structure for organizing all possible (legal) game states by the moves which allow you to transition from one game state to the next. This structure is ideal for allowing the computer to evaluate which moves to make because, by traversing the game tree, a computer can easily “foresee” the outcome of a move and thus “decide” whether to take it.

Next we’ll go into detail about how to determine whether a move is good or bad.

Ranking Game States

The basic approach is to assign a numerical value to a move based on whether it will result in a win, draw, or loss. We’ll begin illustrating this concept by showing how it applies to final game states, then show how to apply it to intermediate game states.

Final Game States

Have a look at this Game Tree:

It’s X’s turn, and X has three possible moves, one of which (the middle one) will lead immediately to victory. It’s obvious that an AI should select the winning move. The way we ensure this is to give each move a numerical value based on its board state. Let’s use the following rankings:

Win: 1
Draw: 0
Lose: -1

These rankings are arbitrary. What’s important is that winning corresponds to the highest ranking, losing to the lowest, and a draw’s between the two.

Since the lowest-ranked moves correspond with the worst outcomes and highest-ranked moves correspond with the best outcomes, we should choose the move with the highest value. This is the “max” part of “minimax”. Below are some more examples of final game states and their numerical values:

You might be wondering whether or not we should apply different rankings based on the player whose turn it is. For now, let’s ignore the question entirely and only view things from X’s perspective.

Of course, only the most boring game in the world would start out by presenting you with the options of “win immediately” and “don’t win immediately.” And an algorithm would be useless if it only worked in such a situation. But guess what! Minimax isn’t a useless algorithm. Below I’ll describe how to determine the ranks of intermediate Game States.

Intermediate Game States

Have another look at this game tree:

As you can see, it’s X’s turn in the top Game State. There are 3 possible moves, including a winning move. Since this Game State allows X to win, X should try to get it if possible. This Game State is as good as winning, so its rank should be 1. In general, we can say that the rank of an intermediate Game State where X is the current player should be set to the maximum rank of the available moves.

Now have a look at this game tree:

It’s O’s turn, and there are 5 possible moves, three of which are shown. One of the moves results in an immediate win for O. From X’s perspective this Game State is equivalent to a loss, since it allows O to select a move that will cause X to lose. Therefore, its rank should be -1. In general, we can say that the rank of an intermediate Game State where O is the current player should be set to the minimum rank of the available moves. That’s what the “mini” in “minimax” refers to.

By the way – the above game tree probably looks ridiculous to you. You might say, “Well of course you shouldn’t make such a dumb move. Why would anyone give up a win and allow O to win?” Minimax is our way of giving the computer the ability to “know” that it’s a dumb move, too.

To sum up:

Final Game States are ranked according to whether they’re a win, draw, or loss.
Intermediate Game States are ranked according to whose turn it is and the available moves.
- If it’s X’s turn, set the rank to that of the maximum move available. In other words, if a move will result in a win, X should take it.
- If it’s O’s turn, set the rank to that of the minimum move available. In other words, If a move will result in a loss, X should avoid it.

And that’s the minimax algorithm!

Ruby Example

Below is a Ruby implementation of Tic-Tac-Toe. It has a few limitations – for example, the computer always plays X. This is beacuse it’s meant to illustrate the concepts described here.

To run it, copy it to something like “tictactoe.rb” and run ruby tictactoe.rb.

You can view the repo on github. In the future, I might add Common Lisp and C versions of Tic-Tac-Toe, and I’d welcome versions in other languages as well.

minimax/tictactoe.rb

# This is a pretty naive implementation of Tic-Tac-Toe meant to
# demonstrate the minimax algorithm. Note that it takes awhile to
# start up - 30 seconds on a 2010 mac book air. Also note that the
# Ruby isn't all that great as Ruby, but I don't care as long as it
# illustrates the algorithm well.
#
# You can see that there's a hard-coded assumption that the AI is the
# X player, means that no human will ever be able to win. I'm positive
# that is only a small taste of what is to come, once robots take
# over the world.

class GameState
  attr_accessor :current_player, :board, :moves, :rank

  def initialize(current_player, board)
    self.current_player = current_player
    self.board = board
    self.moves = []
  end
  
  def rank
    @rank ||= final_state_rank || intermediate_state_rank
  end

  # this is only ever called when it's the AI's (the X player) turn
  def next_move
    moves.max{ |a, b| a.rank <=> b.rank }
  end

  def final_state_rank
    if final_state?
      return 0 if draw?
      winner == "X" ? 1 : -1
    end
  end

  def final_state?
    winner || draw?
  end

  def draw?
    board.compact.size == 9 && winner.nil?
  end

  def intermediate_state_rank
    # recursion, baby
    ranks = moves.collect{ |game_state| game_state.rank }
    if current_player == 'X'
      ranks.max
    else
      ranks.min
    end
  end  

  def winner
    @winner ||= [
     # horizontal wins
     [0, 1, 2],
     [3, 4, 5],
     [6, 7, 8],

     # vertical wins
     [0, 3, 6],
     [1, 4, 7],
     [2, 5, 8],

     # diagonal wins
     [0, 4, 8],
     [6, 4, 2]
    ].collect { |positions|
      ( board[positions[0]] == board[positions[1]] &&
        board[positions[1]] == board[positions[2]] &&
        board[positions[0]] ) || nil
    }.compact.first
  end
end

class GameTree
  def generate
    initial_game_state = GameState.new('X', Array.new(9))
    generate_moves(initial_game_state)
    initial_game_state
  end

  def generate_moves(game_state)
    next_player = (game_state.current_player == 'X' ? 'O' : 'X')
    game_state.board.each_with_index do |player_at_position, position|
      unless player_at_position
        next_board = game_state.board.dup
        next_board[position] = game_state.current_player

        next_game_state = GameState.new(next_player, next_board)
        game_state.moves << next_game_state
        generate_moves(next_game_state)
      end
    end
  end
end

class Game
  def initialize
    @game_state = @initial_game_state = GameTree.new.generate
  end

  def turn
    if @game_state.final_state?
      describe_final_game_state
      puts "Play again? y/n"
      answer = gets
      if answer.downcase.strip == 'y'
        @game_state = @initial_game_state
        turn
      else
        exit
      end
    end
    
    if @game_state.current_player == 'X'
      puts "\n==============="
      @game_state = @game_state.next_move
      puts "X's move:"
      render_board
      turn
    else
      get_human_move
      puts "The result of your move:"
      render_board
      puts ""
      turn
    end
  end
  
  def render_board
    output = ""
    0.upto(8) do |position|
      output << " #{@game_state.board[position] || position} "
      case position % 3
      when 0, 1 then output << "|"
      when 2 then output << "\n-----------\n" unless position == 8
      end
    end
    puts output
  end

  def get_human_move
    puts "Enter square # to place your 'O' in:"
    position = gets

    move = @game_state.moves.find{ |game_state| game_state.board[position.to_i] == 'O' }

    if move
      @game_state = move
    else
      puts "That's not a valid move"
      get_human_move
    end
  end

  def describe_final_game_state
    if @game_state.draw?
      puts "It was a draw!"
    elsif @game_state.winner == 'X'
      puts "X won!"
    else
      puts "O won!"
    end
  end
end

Game.new.turn

The End… or Is It???

I hope that explains the algorithm! If anything’s unclear, please let me know in the comments below. I’d like for this post to explain the algorithm completely, and I’ll use any feedback to revise it.

Also, you may have noticed that the algorithm, as written, requires a lot of memory. Tic-Tac-Toe, one of the simplest, most boring games in existence, requires hundreds of thousands of game states in the above, naive Ruby implementation. In the future, I may cover some optimization techniques, like alpha-beta programming. Look for it!

P.S.

My motivation for writing all this came from reading Land of Lisp: Learn to Program in Lisp, One Game at a Time! , which introduced me to minimax. It’s one of the best programming books I’ve read: it was fun to read, and I learned a lot :) It’s also the only programming book I know of to have its own music video.

A Philosophy of Programming, Rough Sketch

2012-01-05T19:02:00Z

A Philosophy of Programming, Rough Sketch

Below is a first attempt at describing an integrated approach to programming. My hope is that it’ll give programmers some tools to reason about their current practices and generate ideas on new practices to implement.

The unifying idea is that our work is governed by cognitive processes and that we can better understand our work by understanding those processes. There is a wealth of information available on such topics as memory, attention, focus, and emotion, and I believe that it will be fruitful to relate such information directly to the processes involved in programming.

Put another way, understanding our hardware will help us understand the behavior of our software.

There are a lot of gaps. My hope is that I’ll get a lot of feedback that will help me fill in those gaps.

The Processes

There are three main processes involved in programming:

Learning
Problem Solving
Social interaction

This article only addresses learning. Future articles will address the other two topics.

Learning

We constantly need to learn: existing codebases, new libraries, the problem domain, the application environment.

Learning consists of relating new information to existing knowledge.

Memory

Ease of learning is in part determined by short term memory. To learn, it is necessary to hold multiple mental objects in short term memory in order to compare them to each other and discover the relationships between them.

Not all mental objects are created equal. Some take up more “space” than others. Familiar objects take up less space than unfamiliar objects. For example, the following list is relatively easy to hold in memory:

bed
cup
light

The following list is harder to hold in memory:

clorp
farg
dwesh

Short term memory also has a temporal limitation (obviously). We should avoid creating the need to hold objects in memory for longer than our brains are designed for. We’ve all experienced the strain produced by having to navigate back and forth among multiple files in order to figure something out. More on this later.

Naming

The nature of memory explains why it is necessary to name things well in code. The explanation is two-fold (using method names as an example):

Without proper naming, it is more likely to be necessary to derive the behavior of a method from its constituent parts. This requires loading more items into your short-term memory, possibly resulting in your forgetting why you were looking at the method in the first place. The result is that learning time is increased.
Indescript names also take up more “space” in short term memory, making it more difficult to understand how a method relates to the larger system.

Examples needed.

Metaphor

Metaphor is at the heart of programming: stacks, queues, pipes, memory, objects, domain models. These are all metaphors. Metaphor is at the heart of our craft.

We also use the term “abstraction”, but I think “metaphor” is better when it comes to naming, as it more directly denotes that we are relating new concepts to existing concepts. But the distinction really doesn’t matter.

Good metaphors allow us to hold more information-dense items in memory. They provide more “hooks” which allow for easier retrieval from long-term memory.

Other “metaphors”:

Visual form of code. Indentiation stands for hierarchy.
Code colorization. Color stands for syntax.
Programming style. Shared programming style allows people to derive meaning from the structure of the code.

All of these examples of metaphor reduce the number of mental objects we need to retain in short-term memory, thus making learning easier. You can easily confirm that it’s much easier to hold “stack” in memory than it is to hold “a last in, first out abstract data type and linear data structure.”

Visual Aids

Visual aids are information-dense. Our visual brains are pretty awesome at processing visual aids. My little treatise on visual design: Clean Up Your Mess.

Documentation

API documentation is not enough. People who use your code have the following questions, among others:

What is the purpose of the system?
What are the subsystems, and what are their purposes?
How do the parts interact?
How do I extend it?

It’s not reasonable to expect someone to answer these questions by reading code and API documentation. Because there are so many pieces involved, it is very difficult for someone to a) determine which pieces are relevant and b) hold the relevant pieces in mind long enough to deduce the answer to his question. Such a process often involves navigating multiple files, constantly having to refresh our memories by looking at the same pieces of code over and over.

It’s possible to answer questions like the ones listed above using the process I listed above, but it’s not optimal. Good documentation condenses the information, making it understandable without producing so much cognitive load.

Examples of good documentation:

nanoc. It was very easy to learn how to use nanoc because the documentation is excellent. If I had to learn how to use it by reading the code, I wouldn’t have bothered. If I had to learn solely by going through examples, it would still have been very difficult. Instead, the documentation provides a mixture of prose and examples which made learning the system very easy.
Whoops. Well, maybe I’m being a little vain and/or delusional here, but I think my documentation for Whoops is above-average. There’s still a good amount that I could cover, though.

Also see my article on documentation

Learning Skills

Describe What You Don’t Know

Being able to concretely determine what it is you need to know is of great value. Learn to quickly transform the emotion of confusion into a concrete statement of what you need to learn.

Ask About it Directly

Often, when seeking help, we ask the wrong question. Need examples.

Confirm Your Knowledge

State and restate what you think you know to someone else who can tell you whether you’re wrong. Often, we make a lot of unconscious assumptions when trying to learn, and this process will help you uncover those assumptions.

To explore

How does emotional state affect learning?
How is emotion related to certrainty?
What is the relationship between testing, memory, and learning?
How can teams support learning?
Find concrete examples of codebases which support learning
How information navigation is related to learning, e.g. including a table of contents in documentation

Why I Don't Want to Start a Startup

2011-08-04T02:30:00Z

Why I Don’t Want to Start a Startup

Over the course of my programming career I’ve spent a little more than two years working at startups. At the time, I thought that the experience would help me when I eventually started my startup. Instead I became convinced that the startup life is not for me.

Reason #1: I Don’t Want to be Like the Founders I’ve Known

The reason why I stopped working at one of the startups was because the founder had me work for a month and a half without paying me and without telling me he was having cash flow problems.

The founder – let’s call him “Reginald” – had been late in paying me before, so when I didn’t receive a check on time I didn’t think much of it. However, when I hadn’t been paid after 45 days I asked him what was going on and he told me he didn’t have the money to pay me and wouldn’t for four months. During those 45 days, he had known that he wouldn’t be able to pay me, yet he didn’t say anything to me about it.

Instead, he had me to continue to work under the assumption that I would get paid in a timely manner. I ended up confronting him about this, telling him that he had been dishonest with me. His rationale for his behavior was that he wanted me to embrace a more entrepreneurial spirit. The idea is ludicrous, but even if it were not, it was not his right to make that decision for me.

What made this worse was that I had considered us to be friends. How could someone whom I had worked with for nearly a year treat me that way? How could someone who I thought considered me a friend disrupt my life so tremendously?

And it did disrupt my life. I was supporting someone who was very ill and required expensive treatment. “Reginald” knew that, yet he decided to set me back financially anyway. All of a sudden I was without income, and forty-five of the days I could have spent looking for a new job were taken from me. It was one of the most stressful periods of my life.

The point of this is not to excoriate “Reginald”. The point is that I don’t want to become like him. My interpretation of his behavior is that his startup was so important to him that he was willing to disregard honesty and integrity and inflict suffering on a friend in order to buy a little more time for it.

I could see myself behaving like that. If I had come to identify myself as a failure and saw my social status – my identity, even – as tied to the success of my business, it’s possible that I’d behave just as he did. Or at least, I might be tempted to. I’d like to think that I wouldn’t, but the point of all this is that I don’t want to put myself in a position where I’d have to find out.

Reason #2: I Don’t Think Financial Freedom is Required for Happiness

One of the reasons I wanted to start a startup was that I liked the idea of having the financial freedom to do whatever I want. I thought that would allow me to be happier.

In the past few years, though, I’ve come to learn that happiness is something you learn to cultivate, and that it’s not something that just happens as a result of changes to your external environment.

This is something that’s hard for me to put into words, so I’ll just steal the words of Thich Nhat Hanh (even though I feel a little pretentious quoting him here):

Freedom is above all else freedom from our own notions and concepts. If we get caught in our notions and concepts, we can make ourselves suffer and we can also make those we love suffer.

— Hanh, Thich (2003). No Death, No Fear (p. 11). Riverhead. Kindle Edition.

What good would it do me to be constantly reinforcing the concept that financial freedom is required for happiness? It didn’t do “Reginald” any good. Instead of working myself to death day in and day out, why not concentrate on being happy now?

Reason #3: I Already Have Big Challenges

Another reason the idea of starting a startup appealed to me is that it seemed like a fun challenge. To be honest, it still seems like it could be a fun challenge. It’s just not one that I want to take up right now.

For a little more than a year now, the challenge I’ve set for myself is to express love regardless fear. That expression can take many forms, whether it’s just telling a co-worker that I think they’re great or telling a friend that I’m glad she’s in my life or telling my girlfriend that she’s wonderful.

It’s also influenced how I see my side projects. At the beginning of the year I decided that, for 2011, I’d only work on side projects that will be freely available and that come from my desire to help other people.

Clean Up Your Mess was the first such project, and it was born of my desire to help other people experience the joy that I feel when I’m attempting graphic design – to give them some tools that will allow them to communicate more clearly and creatively. I’ve received numerous tweets, emails, and comments on how the site has been useful, and those notes have been very gratifying to me.

There were many times, though, when I thought it was pointless to work on the project. I imagined people criticizing it, calling it confusing or boring or worthless (which hasn’t happened). The idea of expressing love regardless of fear kept me going, though.

There are many more “projects” I’d like to tackle, all of which seem more interesting than starting a startup. I’d like to be a better friend and a better brother. I’d like to get better at lifting other people up. I’d like to communicate better. All of these challenges are meaningful to me.

And they don’t require me to live on ramen for the next three years.

Thank You

2011-05-02T04:00:00Z

Thank You

Thank you, everyone who has viewed Clean Up Your Mess. Thanks as well to everyone who has passed it on.

I made it because I want to help as many people as possible learn about and enjoy design, so it makes me happy to see that people are reading it and finding it worth telling other people about it.

Clean Up Your Mess has been the most difficult and time-consuming of all the side projects I’ve worked on. I was constantly questioning whether I was spending my time well and whether other people would find the guide useful. The past couple days have been very gratifying for me, and it feels like all the work was worth it.

Higml: Hierarchical, Cascading, Dynamic Configuration

2011-01-22T04:23:00Z

Higml: Hierarchical, Cascading, Dynamic Configuration

Purpose

Higml allows you to write hierarchical, cascading, dynamic configuration files with Ruby. It visually reflects the conditions governing how rules are applied, allowing otherwise-complicated rules to be expressed concisely and understood easily.

Examples

Applying Hierarchical, Cascading Rules

# Higml rules; let's pretend they're in rules.higml
action:create
  :channel Create Saved Search
  
action:show
  :channel Search
  
  search_type:job
    :channel Job Search
  
# Let's pretend the following is run by ruby
rules = "rules.higml"

input1 = {:action => "show"}
input2 = {:action => "show", :search_type => "job"}
input3 = {:action => "create", :search_type => "job"}

Higml.values_for(input1, rules)
~> {:channel => "Search"}

Higml.values_for(input2, rules)
~> {:channel => "Job Search"}

Higml.values_for(input3, rules)
~> {:channel => "Create Saved Search"}

Higml checks an input hash for key/value pairs and builds an output hash. Higml rules are cascading in that if a matching rule is defined later in the Higml file, it takes precedence over a previously defined rule.

You can see this with inputs 1 & 2. input2 matches the action:show rule, but it also matches the search_type:job rule which is defined later. The search_type:job rule therefore takes precedence.

Higml is hierarchical in that it does not apply child (indented) rules if the parents don’t match. You can see this by comparing inputs 2 & 3;

Dynamic Output

 # Higml rules; let's pretend they're in rules.higml
action:show
  :keywords= @keywords

# Let's pretend everything that follows is run by ruby
# Context object
context = Object.new
context.instance_variable_set(:@keywords, "cat mouse bird")

# Higml invocation, including context object
Higml.values_for({:action => "show"}, 'rules.higml', context)
~> {:keywords => "cat mouse bird"}

Whenever Higml encounters = in the output definition, it uses instance_eval on the context object on the text that follows; in this case, @keywords.

Rule Application Summarized

Rules take the form input_key:value or input_key. If value is not present, any value (including nil) will cause the rule to be applied.
Multiple rules can be present on the same line, separated by commas. Example: action:show, action:new. This is equivalent to an OR – if any rule matches, the rule is applied.
Indented (child) rules are only checked if their parent matches.
Output definitions take the form :output_key Value or :output_key= code_instance_evald_in_context.
Output definitions written later on the page take precedence over those written earlier,

Pronunciation

It’s pronounced like “hig-uh-mole”.

Writing Better Documentation

2011-01-20T04:23:00Z

Writing Better Documentation

The learning curve for code libraries is often unnecessarily steep. I frequently feel that if the author had written better documentation, I’d be able to use his work much more quickly, or at least figure out that it’s wrong for me and move on.

My own work could use better documentation, and that’s part of why I’ve started using nesta as my blogging engine. Nesta looks like it provides just enough of a framework for me to efficiently write articles which are mainly text. More importantly, there’s room for me to easily extend it in order to explore different ideas for creating code documentation efficiently. As a first step, I’ve written a few lines that will allow me to easily include source code in a textile document:

custom_tags.rb

def source(opts)
  local_path, highlighted, range = /([^ :]*)(?::(\d+))?(?: (\d+-\d+))?/.match(opts[:text])[1..3]
  code = File.readlines(File.join(File.expand_path(File.dirname(__FILE__)), local_path))
  if range
    start, finish = range.split("-").collect{|i| i.to_i}
    code = code[(start-1)..(finish-1)]
  end
  start ||= 1
  
  indentation_level = /^ */.match(code[0])[0].size
  code.collect!{|l| l.sub(/^ {#{indentation_level}}/, '')} #remove indendation
  code = code.join
  
  html = "<div class='attachment-path source'>"
  html << "<a href='/assets/source/#{local_path}'>#{local_path}</a></div><div class='code pygments'>"

  html << IO.popen("pygmentize -O linenos=table,linenostart=#{start} -f html -l ruby", 'a+') do |pygmentize|
    pygmentize.puts code
    pygmentize.close_write
    result = ""
    while (line = pygmentize.gets)
      result << line
    end
    result
  end

  html << "</div>"
  
  html
end

Hopefully that will come in handy when I want to include other, less self-referential snippets.

In the mean time I’ve also been thinking about what makes good documentation. Tom Preston-Werner recently wrote an article urging developers to write a README before coding, and I think that’s advice worth trying, though I haven’t tried it myself. Unfortunately, he’s not very specific on what should be included in the README. Personally, it’d be a lot easier for me to write a README if there were some formula I could follow. I also believe that other programmers would write better documentation if they had the tools that facilitated the joy and creativity that they experience with programming.

My initial thought on good documentation is that it should include the following:

The purpose of the code
When it should be used and when it shouldn’t (i.e. “This authentication library is great if you don’t require much customization.”)
Installation
Basic usage
How to extend it
Its “home”
Links to further documentation
Other quality libraries which address the same problem
A brief tutorial

That… looks like a lot of work. (Googling “what goes in a readme” also reveals that it looks a bit like this excerpt from Ruby Best Practices). It also looks like it shouldn’t all be put in the README.

In any case, my next little project is to write some documentation for a little library I created. After that I’m sure I’ll have a better idea of what makes good documentation.

Blog Reboot

2011-01-14T18:11:26Z

Blog Reboot

It’s been nearly a year since I’ve added anything to this site. There are a few reasons for that, though for now I’ll only mention that I didn’t like that the site existed in part to sell an iphone app and possibly future apps. Well, it turns out that I don’t really care about selling stuff. What I really want is a place to write about I care about most.

And that might make this site kinda weird. I plan on writing about design, programming, aikido, buddhism, communication, and a host of other topics which aren’t usually seen rubbing elbows. The thread which wends its way through all these topics is love.

With design, I’ll share my attempts at creating layouts and interfaces which are a joy to use. With programming, I’ll share the code I’ve written, and hopefully it will help other folks. With aikido and buddhism, I’ll probably just share my thoughts on what I’ve read and practiced. My obsession with communication will probably be evident in most things I write, and it is, after all, why I want to write anything in the first place.

So that’s what this site is for. Not to sell or persuade, but just to share the things I love.

Models for Dealing with Fear

2010-02-15T18:53:00Z

Models for Dealing with Fear

There is a popular kind of article on Hacker News that is always 1/3 self-deception. The content of the article can be boiled down to three parts:

A description of some cool accomplishment by the author or someone he knows
The behaviors which lead to that accomplishment
The world-view which allowed the accomplisher to feel comfortable with the behaviors

For example, recently How I Landed A $50/hr Side Gig With Very Little Effort & How It Relates To Picking Up Chicks made it to the front page of HN. It can be broken down to:

I landed a $50/hr side gig with very little effort
To do this I was concise, friendly, abundant, value-offering, indifferent
I felt comfortable acting this way because I believe:
- You have complete control over the universe because it only exists in your head
- Other people are only projections of your own consciousness. If you are not a friend to everyone then you are not a friend to yourself.

Which part do you think comprises the self-deception?

Models for Overcoming Fear

These kinds of articles are perennially interesting because, at their heart, they’re moral stories about overcoming fear. The author describes a situation where most people would feel fear – fear of humiliation, fear of loss, fear or failure – and shows how his world-view allowed him to cope with the fear well enough for him to exhibit the behaviors which lead to his success. These stories keep alive our hope that we, too, can overcome our fears and live how we want.

However, these stories present their world-view as fact, and I think that’s where the self-deception lies. The world-view is considered to be absolute truth, when really it’s just a model that’s proven useful.

I think this is easy to see in the example above. You probably would not agree that “you have complete control over the universe because it only exists in your head.” You could try this model out for yourself by compelling the universe-in-your-head to add millions to your bank account, only to find that all you’ve done is whittled away another fraction of your life. Yet, it’s undeniable that this model has helped the above author and others to overcome their fears and do cool shit.

The world abounds with wacky models that help actual people actually overcome actual fear. Some people believe their obstacles are put there by God as tests for them to pass. Others believe that mortal life is a game played by immortal energy beings, just for the fun of it. And some folks believe that there is nothing more to life than what we see; when we die, that’s the end, so we better make the most of it. Wacky!

Models for Justifying Fear

Just as models help us overcome fear, they also help us justify fear. When we were teenagers, one of my best friends made all her decisions based on the statistical likelihood that she would be successful. She adopted a model of the world where her fear of failing had to be heeded: “Since so many other people have failed at being an artist, it’s likely I will fail too. I will therefore become a teacher, avoiding the pain and humiliation of constant rejection.” Obviously she never said that, but that’s how it seemed to me.

I’m not saying she was wrong to think this way. What I am saying is that we adopt different models to help us cope with fear, and that we often deceive ourselves into thinking these models are absolute truth. When our models have outlived their usefulness — when they no longer allow us to be happy — we find it hard to change them because we believe that our models are reality itself rather than interpretations of it.

Which models are more useful — those that help us overcome our fears or those that justify them? Well, this is honestly a bit of ridiculous question. These models are more complex than the question allows, and besides that, I think that there’s no One True Model. Rather, it varies by person and context.

Regardless, it’s worthwhile to breakdown our world-views, our models of reality, so we can better understand them and, possibly, change them.

World-Views Dissected

Our world-views are made up of three parts: the universe, you, and your relationship to the universe. I’m stealing from Ayn Rand a bit here, but those parts can be broken down further (I apologize for compressing all of philosophy into three ridiculous lists):

You

Yeah, this has gotten deep. Are your abilities fixed, or are you capable of improving them? How about your emotions, your personality? Are you good, bad, amoral? Does it depend? What does it depend on? Does it depend on who you have been up to this point? Does it depend on who’s asking?

The Universe

Is the universe benevolent? Malevolent? Indifferent? Is it chaotic or orderly? Is it fair? Is it just? Is it meaningful or meaningless? Are you capable of comprehending it? Is it all in your head? Do you control all of it? Part of it? None of it?

Society

What is your place in society? Are you able to influence other people? Are you controlled by other people? How much control do you have, and in what situations? Do you fit in? Will you never fit in?

Obviously, it’s possible to ponder these questions for millennia. Hopefully what’s listed here will help you to analyze your own world-view and to analyze other possible world-views.

The Model to End All Models: Life as an Improv Game

This article wouldn’t be complete without my own unimpeachable advice on what works. Lately I’ve been experimenting with approaching life as an improv game, and I’ve really enjoyed it.

Improv games have the following guidelines:

There’s a set of rules, but within those rules anything can happen.
You don’t control what will happen next, but you control your reaction.
Whatever happens, run with it. Say “yes” to it.
It’s only a mistake if you say it’s a mistake.
You’re there to make your team look good.
Your team will support you.
Have fun, or else.

This model has greatly helped me overcome social fears. It’s helped me approach life with a much more adventurous spirit.

Perhaps in another article I’ll give a real-life example about how this approach has served me. I could call it “How I Went from Folding Laundry for The Man at $8.75/hr to Living in Hawaii and Making $90/hr Working for Myself at 21 Years of Age”. It’d be about accomplishing cool shit and overcoming fears along the way. It would be ninety percent true.

In the mean time, I hope this article has helped to clarify your own thinking about the way you cope with fear in your life. My belief is that once you accept that your world-view is only a model and not absolute Truth, it’s easier to discard it in favor of a more useful one. One that will make you happier.

Look Into My Eyes

2010-01-10T16:46:00Z

Look Into My Eyes

My first attempt to give myself super powers merely gave me sore palms. Riding in the back of my mother’s beater as a five-year-old, I focused sunlight on the center of each hand using a magnifying glass likely found in a cereal box. After I was “charged up” I would point at trees, cars, fire hydrants, and other hapless objects and think to myself, “In five years, that thing’s going to burst into flames.”

A couple years later I set out to hypnotize people. Wagging a watch in front of my friends’ faces and intoning “You are getting very sleepy” had little effect. By that time I could read well enough to consume hypnosis books at the local library. I learned to put myself in a trance, making myself unable to lift my own arm. Making yourself immobile didn’t seem suitably spectacular for a super power, so I moved on to practical endeavors like building electric motors and crystal radios.

Still, the promise of hypnosis is compelling in a deep, almost primordial way. Since the time of our earliest ancestors, we humans have believed in the power to manipulate the world — our environments, our fellow humans, and ourselves — with mere words. The ability to wreak devastation or relieve suffering with spells and incantations still captures our imaginations. What I would give to be able to say “abodicus immaculatus” and have my house cleaned!

Many even believe in this power literally, especially when it comes to religion. Here in America, the majority still believe that prayer offers us a direct link to God, and many believe that saying prayers can relieve illness or financial hardship. One sect of Buddhism holds that you merely need to recite a prayer, even without meaning it sincerely, and after death you’ll exist in nirvana as a buddha on a golden lotus for all eternity, while in ancient Jewish tradition pronouncing YHWH, one of the names of God, was punishable by death.

Our species is at once terrified of what words can do and faithful in their power to heal and save, and hypnosis is still viewed in both these lights. A quick google search for “evil hypnosis” yields this quote: “It is obvious that hypnosis is lethal if used for evil purposes.” If you’re willing to take this risk, you’ll find that hypnosis can help with “weight loss, smoking cessation, pain management, public speaking, creativity, astral travel, self confidence” and on and on and on.

I began seriously trying to learn hypnosis again in high school, mostly out of curiosity. My interest was piqued after reading an essay by Aldous Huxley where he described the beneficent uses and effectiveness of hypnosis. I remember thinking to myself, “If he thinks it’s so great then maybe there’s something to it.” So once again I immersed myself in hypnosis books, this time with a realistic idea of what hypnosis can accomplish. None of my family would submit themselves to my budding powers, so it wasn’t until college that I actually got a chance to try and hypnotize someone.

After a lot of badgering, my new friend Lea agreed to be hypnotized. One night we went to her dorm room and she lied on her bed while I sat nearby and tried going through a script. We both tried not to laugh when the script had me saying “Remember: you are in control. You are in the driver’s seat” over and over in my best monotone. Lea never did get hypnotized all the way, but she said afterward that she became deeply relaxed and that it felt good. Even if I wasn’t 100% successful, the experience was thrilling.

However, the real power of words was revealed years later when I deeply hurt Lea without realizing it. She had come to visit me in the house we had originally rented together after our first year of college. During our year of college and co-habitating we went through some crazy, crazy stuff together — family problems, relationship problems, and one surreal night at the hotel where I worked involving college applications, Aerosmith, gun shots, and flooding — and we’d become great friends. So it made me really happy that she was staying with me and we’d get to spend time together. Yet, one morning a few days after she arrived, she was gone.

The previous night we’d had a discussion about politics — healthcare, actually — and I acted like a complete ass. I didn’t just disagree, I was strident and contemptuous in my disagreement. I cut her off, raised my voice, acting in a way no friend should act. Looking back now, my behavior seems even more ridiculous because my views on healthcare have completely changed, matching hers.

Eventually we smoothed things out and we remain great friends, but I’ve tried not to forget the lesson of that experience. Lea had left a note that said I must think her stupid to say some of the things I did. I’ve never thought Lea stupid, but I was so concerned with making my points that I succeeded only in pushing her away, rather than connecting with her and understanding her, as I would try to do now.

Over time I’ve come to appreciate the inescapability of the fact that we’re islands of consciousness, that we are forever bound to see the world from within our skulls. Some people claim that they’ve achieved a feeling of oneness with all of humanity, but I certainly never have. It’s often a struggle to bridge the vast gap between my island and the islands of those I love most, to say nothing of acquaintances or strangers. Words are a material — perhaps the most abundant — for building those bridges, or destroying them.

Last year I saw a different friend for the first time in five years. We had been through a lot together and it made me more than happy to see him, but it quickly became obvious he had changed. The morning after arriving he asked, “Hey is there a place around here I can get some Bud Light?” For the remainder of his stay he almost always had a drink with him. Over six days he drank at least thirty-six cans of beer, plus some bottles here and there. Despite the amount he drank he seemed pretty normal, and I probably wouldn’t have even known if I hadn’t seen the cases he bought.

Except one night when we were driving home from the beach. My friend is a very kind, very gentle person. But that night his voice got louder and his speech slurred as he inexplicably argued with me over something that had happened nine years ago. I was scared that night but more scared the next day when he didn’t remember what happened.

Eventually I tried to talk to him about his drinking. I told him it worried me, that even if he considered himself a functioning alcoholic that it was unhealthy for him and dangerous. Looking back, it’s almost like I can see my words soaring toward him, shining and proud and certain. And I can see them falling, can see them limping forward to die at his feet.

I wasn’t able to persuade my friend at all, and I’m afraid that I may have alienated him. What could I have said differently? “Look into my eyes…”

I’ll always love him, I’ll always care about him, and I’ll always be his friend. Hopefully I’ll get a chance to regain his trust. In the mean time, I’m not as concerned with “wielding” my words. I’m cultivating the ability to really listen – not just to what’s said, but to what lies beneath. And in this endeavor, the words of James Merrill have left their mark on me:

“Salt lick big as a fist, heart, hoard
Of self one grew up prizing above rubies —
To feel it even by a grain dissolved…”

Rather than inflicting my “hoard of self” upon people by insisting on my cleverness, my wisdom, or my rightness; rather than hailing others from my superior position, I’m learning to open the fist of my heart and reach out.

I'm Going to Take All the Help I Can Get

2010-01-06T12:06:00Z

I’m Going to Take All the Help I Can Get

A few months ago, I was really psyched about some project (don’t recall which), and said to myself, “I’m going to finish this thing, and nothing’s going to get in my way.” Immediately it occurred to me that a better attitude would be, “I’m going to finish this thing — and I’ll take all the help I can get.”

Expecting that I’ll get help instead of expecting that I’ll encounter conflict and resistance has made me more open about my work. My tendency is to be quite shy about my own work, but I’ve since tried to go out of my way to share it with people.

For example, recently I created a post on Hacker News (and emailed the Boston Ruby Group) asking the folks there if they wanted to start a small group to give and receive writing feedback. The group has 15 members now, and though most appear to be lurkers I’ve met a few great people and got some really excellent feedback on the copy for Control Time.

One fellow I met, Aaron Dragushan, has a site similar to this one: Upgrade Me. It has some great productivity tips, but aims to be about more than just productivity. Exciting stuff! You should check it out – the content’s well written and each post is a pretty quick read.

And by the way, if you’re interested in joining the writing feedback group please do and introduce yourself. We could use some more active members :-)

Control Time Submitted to App Store

2010-01-02T03:56:00Z

Control Time Submitted to App Store

Today I finally wrapped up Control Time and submitted it to the app store :-). Hopefully they’ll publish it soon.

Thanks to my brother Matt for creating the icon and to everyone who tried out the app along the way. Thanks also to the writing feedback group for helping me write ad copy.

This is the first app I’ve submitted, but it won’t be the last!

Update (Jan 4): Wow, the app has already been approved! You can see it on iTunes.

How to Get and Stay Motivated

2009-12-13T03:03:00Z

How to Get and Stay Motivated

A lot of people view their motivation as something out of their control. It comes and goes, catlike in its fickleness. By breaking down motivation to its components, however, you’ll be able to troubleshoot your lack of motivation and figure out ways to increase it.

But first: what is motivation?

Motivation is Your Emotional Energy for Making The Right Choices

Every few months I get excited about doing barefoot running and tell myself I’m going to do it consistently. Running appeals to me as a way to have more energy, to feel healthy, and to clear my head. I have all the gear: running pants, running shirt, a nifty pair of shoes with virtually no sole. And every few months my excitement peters out and my gear collects dust in the closet again – a scenario I’m sure you’re familiar with, in one way or another.

That initial burst of motivation is not enough because changing your lifestyle is not an all-or-nothing proposition. It takes time (some say weeks, some say months) to develop new habits or shed old ones. During that time you’re constantly encouraged to not follow through, whether by yourself or others. If you’re trying to lose weight, for example, you have to pass by McDonald’s and Burger Kings on your drive to work. You have to navigate past countless pastries, candy bars, and other crappy foods when you go grocery shopping. Change is a matter of consistently making the right choices, day in and day out, until making the right choice becomes as easy and habitual as it once was to make the wrong choice.

Resisting the wrong choices and making the right choices takes energy, and motivation is that energy. The reason why I haven’t been able to stick with running is that I’m constantly faced with the wrong choices in a very compelling manner (“Running hurts, but watching movies is fun!” or “It’s cold outside man! Also did I mention that running hurts?”), draining my motivation. My initial burst of motivation isn’t replenished, and my intention to run dies a quiet death.

Instead of just accepting that your motivation will eventually wither, you can deliberately make more. Just like baking a delicious cake, making more motivation requires you know the ingredients. That’s right, making yourself more motivated is just like baking a cake.

The Anatomy of Motivation

Motivation has two main components, Incentives and Confidence. Each has a variety of sub-components.

Incentives

An incentive is, circularly enough, any factor which motivates a particular course of of action or counts as a reason for preferring one choice to the alternatives (says wikipedia). The same incentive will vary in effectiveness depending on how important it is for the individual person. If a gang leader offered to pay you less than minimum wage to risk your life standing on a street corner to sell crack, you would probably decline. Yet there are people who have accepted that offer.

Incentives also differ in their polarity. Positive incentives are incentives that you desire, whereas you avoid negative incentives. You might read to avoid failing a class or to experience the pleasure of expanding your mind. Most people tend to be motivated more by one than the other, and it helps to know which type of incentive works better for you.

There are a few major incentive categories, and it helps to know how you respond to each. In the future I’ll write more on each category individually:

Social: Social incentives involve gaining or losing social esteem. An example would be telling your friends that you’re going to stop smoking. The need to keep their respect by keeping your word is a strong motivating force.
Moral: I think this one is pretty self-explanatory
Financial: This one is too
Personal: Life goals and personal passions would fall under this category. One thing I want to point out here, which I’ll explore more in another post, is that a feeling of worthlessness can be a debilitating form of incentive that completely drains motivation, preventing people from making lifestyle choices.

Confidence

Confidence here refers to your belief that you’re capable of making the right choices. People suffering from addiction can often strongly recognize the need to quit – the addiction is destroying his life and the lives of those he love – but feel helpless to fight it.

Confidence depends on many sub-components:

Knowledge: It’s easy to give up when you feel confused. Since you don’t really know what’s right, you settle for what’s familiar.

Feedback: Taking “knowledge” one step further, it’s essential to get feedback. Chart your progress, get feedback from friends or whoever – whatever works for you.

Expectations: If you underestimate how much time or effort it will take you to do something, it’s possible you’ll get frustrated and feel like you’re not up to the task. On the other hand, if something is easier to do than you expected, it can be a real confidence booster.

Other people: Think of what it’s like to have a boss who shoots down your ideas versus one who supports and encourages you. This component’s especially important when “other people” have power over you, whether actual or merely perceived.

Time: In my opinion this is a very important part of confidence that’s often overlooked. Feeling like you don’t have enough time to change your lifestyle is enough to prevent you from trying. The perception that you don’t have enough time and don’t know how to make it is so detrimental that I’ve made an iphone app to address those issues.

Self-confidence: Your overall feeling of self-confidence obviously affects how confident you’ll feel about accomplishing a particular goal.

Skills & Equipment: These need the least explaining and are the most straight-forward to acquire.

Troubleshoot Your Lack of Motivation

Now that you understand what comprises motivation, you can begin to ask questions that allow you to uncover why you’re not motivated. There are innumerable resources on specific facets of motivation (some of which we’ll cover on this site in the future), but the following troubleshooting outline should allow you to figure out what needs fixing and give you a good start in fixing it.

Do you struggle with conflicting incentives?

An example of this would be trying to lose weight but being afraid that you’ll lose friends who are uncomfortable with a healthy lifestyle. (It sounds weird, but it happens. People are weird.) You might be able to talk to some friends and work things out, even have them join you; or you might have to decide what’s more important, keeping your current friends or being healthy. Or it might be that you have a pantry full of cookies that are always tempting you, in which case you can just throw them out. Either way, it helps to be aware of of the incentives pulling you in the wrong direction.

Are your current incentives important to you?

You might “know” you need to stop smoking because it’s destroying your lungs, but that’s not an important enough reason to stop. Then you might fall in love with someone who can’t stand smoking, and allova sudden you find the motivation to quit. Hooray! You now have an incentive that’s important to you.

If a goal is truly important to you, it’s even possible to “manufacture” an important incentive. Two that work great are writing your goal down and telling other people your goal. In the first case, your incentive is to not let yourself down, while in the second your incentive is to not let down others. What’s most important, however, is knowing what kinds of incentives work for you and structuring your life to include them. How to do so is a topic worthy of a blog post, and in the future I’ll provide one.

Where are you lacking confidence?

Go through the list above and ask yourself if you’re lacking confidence in that area. There are myriad resources that address each area of confidence, and in time I hope to list some on my site and add some of my own. In the mean time, you can always try the best way to gain confidence:

The Best Way to Gain Confidence is to Join a Group with The Same Goals

Joining like-minded people is bar none the best way to gain confidence. You’ll be able to learn from their experience and thus gain knowledge. They’ll be able to teach you the skills you need and loan or give you required equipment. They’ll help you set realistic expectations because they’ve already been through what you’re trying to go through. They’ll provide you with encouragement and feedback. You’ll be glad you’re not going it alone.

The next time you’re lacking motivation, you can pinpoint what’s wrong and take the steps necessary to get more motivated.

Now go out there and be somebody!

The Why of this Site

2009-12-02T03:35:00Z

The Why of this Site

I’m a young software developer and caregiver. This web site is about my experimentations in creating and following a system for constant personal growth. This article gives some background on the circumstances that motivated me to start those experimentations and this site.

It was around summer of 2008 that I realized I had become mean — a small person, constantly irritable and ready to cut down others. I went through nearly every day in a sour mood, showing annoyance and contempt toward those I interacted with regularly and interpreting their behavior as putting me down. It was like I was an angry drunk without the benefit of actually being drunk. At the same time, I clung to trivial diversions like video games and TV, all the while feeling like I no longer had time for anything I liked. In the mean time, my fledgling consultancy had crumbled and I felt like a professional failure.

I was ashamed of myself. I knew I had to change something, but what? And how? For the previous year and a half I had been making chaotic attempts to change the way I felt and behaved. I would start to read a book and stop after the first couple chapters. I would start to create a new habit – for example, of exercising regularly – and quit after a week. Nothing stuck – or, more accurately, I couldn’t stick with anything.

Life hadn’t always been like this. I’ve always been a tinkerer, and as a teenager I fell in love with programming. Beyond its inherent joy, I saw programming as my ticket to freedom, allowing me to go where I wanted and do what I loved. I dreamed of being able to sit on a beach, working on a laptop with a tasty drink by my side. In November of 2005 that dream was realized when I arrived at the Honolulu airport with my laptop, my suitcase, and a little extra money to spend time settling in.

The next year was incredible. I made new friends and grew my business. It was awesome to finish projects quickly and successfully and have my clients tell me how happy they were with my work. At the same time, I was able to work on my own projects for fun and learn new programming languages and technologies (like javascript, ruby, and ruby on rails). And the food! Just minutes a way were handful of great restaurants that had delicious food for cheap prices. For five or six dollars I could buy enough to last me two days. Nearly every morning I woke up to sea breezes blowing my curtains, and I could see a bit of the ocean from my gigantic bedroom window.

Then in December of 2006 my long “vacation” came to an end. The last memory I have of Hawaii is of driving up a hillside in the early afternoon with the sun shining down. Below me the island stretched out to the ocean, and it was beautiful.

I left Hawaii for Massachusetts. When I got on my plane in Hawaii, it was seventy degrees (fahrenheit) and gorgeous outside. When I touched down in Boston, the temperature was below freezing. Better (and perhaps more honest) writers than I would resist symbolizing the weather like this; alas, I find the transition indicative of the upheavals I would deal with in the coming months.

What brought me to Massachusetts, anyway? After years of searching and suffering, my girlfriend had finally received a treatable diagnosis for the disease that had disabled her: Lyme Disease. In order for her to receive better medical care, we moved to Massachusetts, where we would be close to “Lyme-literate” doctors and friends as well.

Lyme Disease, if it goes untreated, can cause severe physical and neurological damage. Its victims are left without energy and in constant pain. Lyme sufferers also experience memory loss, rages, aphasia, and a host of other symptoms that leave them doubting whether they are, or ever will be, the person they were before getting Lyme.

My attempts to develop a system for constant personal growth and fulfillment are primarily the result of my taking on the role of caregiver for my girlfriend. At the time, I thought of it like I did my work projects. It would take a little extra effort for awhile, and then it’d be over and I moved on to something else. But work has never been so stressful, nor so heartbreaking.

Some issues which caregiving brought which I’d never dealt with include:

Being interrupted urgently, often, and without warning. Programming requires long stretches of concentration and can be like building a house of cards in your mind; interruptions, even slight ones, can knock the house right over. Being interrupted over and over makes it difficult to even start concentrating in the first place.
Living in a constant state of emergency. Will this new medication cause a negative reaction? How bad will it be? Ambulance bad, or “just” throwing up all night bad?
Watching the one you care for suffer, and knowing there’s nothing more you can do about it.
Feeling guilty about everything. Guilty about being healthy. Guilty about being sick, when sick. Guilty about not doing enough. Guilty about doing too much and being exhausted. Guilty about trying to relax. Guilty about feeling guilty.
Feeling angry about feeling guilty.
Feeling angry and discouraged over the perceived lack of caring in others, including friends and family.

Over a period of years, these experiences wore me down completely. Trying to balance my full-time job, caregiving, and my personal life continues to be a challenge, but I think I’m improving. This site is part of my effort to accomplish meaningful change – to continuously learn about myself and others, to grow as a human being, and to do the things I love. I’ll be focusing on the principles of change more than the techniques. I hope you find it useful, and I look forward to continuing this conversation with other like-minded people. Onward and upward!

Follow Your Followers Using Ruby

2009-05-21T04:23:00Z

Follow Your Followers Using Ruby

I have the following in a rake task run every 30 minutes. You’ll need jnunemaker’s twitter gem.

follow-your-followers.rb

require 'twitter'
# Check out the twitter gem docs for using oauth
httpauth = Twitter::HTTPAuth.new("username", "password")
base = Twitter::Base.new(httpauth)
to_follow_ids = base.follower_ids - base.friend_ids
unavailable_count = 0
to_follow_ids.each do |tfid|
  begin
    base.friendship_create(tfid, true)
  rescue Twitter::General
    # Twitter::General is raised for 403 errors
    # Which occur when you're trying to follow someone who's been banned by twitter
    base.block(tfid)
  rescue Twitter::Unavailable 
    # Wait and try again if twitter's telling you to wait
    sleep 5
    if unavailable_count < 3
      retry
      unavailable_count += 1
    end
  end
end

Aikidoka Prevents Namespace Collisions

2009-05-11T04:23:00Z

Aikidoka Prevents Namespace Collisions

Recently I fell victim to the Twitter-Mash / Extlib-DataMapper-Mash namespace collision. To get around this problem, I’ve created a new gem, Aikidoka".

Here’s what happened when I tried to use Twitter when Extlib had already been loaded:

irb(main):001:0> require 'Twitter'
=> ["Twitter"]
irb(main):002:0> Twitter::Search.new("bokken").fetch
SystemStackError: stack level too deep

Here’s what happens when you use Aikidoka:

irb(main):001:0> require 'aikidoka'
=> ["Aikidoka"]
irb(main):002:0> Aikidoka.rename("Mash" => "Twitter::Mash"){require 'twitter'}
=> ["Mash"]
irb(main):003:0> Twitter::Search.new("aikidoka").fetch
=> <Mash completed_in=0.052875 max_id=1754360060 next_page="?page=2&max_id=1754360060&q=aikidoka">
etc...

It works! What this does is namespace the Mash defined when I require the Twitter gem, so that Mash is now Twitter::Mash. Also, Extlib’s Mash is still there, untouched, so you don’t need to worry about that. Here’s how Aikidoka does its magic:

It temporarily renames existing constants so that they don’t get clobbered. In this case, “Mash” is renamed to “AikidokaMash”. Right now this only works with top-level constants.
It yields to the given block. This block should define the constants you want permanently renamed/namespaced. In this case, we’re requiring “twitter”, which in turn requires “mash”. “mash” defines the constant we want to rename, Mash.
It creates modules as necessary to create the namespace. In this case, the module Twitter is already defined so that’s used. However, if we wanted to rename “Mash” to “Potatoes::Mash”, then a module named “Potatoes” would have been created.
It assigns the object referred to by the old constant to its new constant. “Twitter::Mash” now refers to the same object that “Mash” refers to.
Old constants are removed to clean up the namespace. The constant “Mash” no longer exists, the object it used to refer to lives on.
The constants temporarily renamed in step 1 are now given their original names back. Extlib’s “Mash” is no longer “AikidokaMash”; it’s “Mash” again.

The code is very simple – a total of 67 lines in one file with decent specs – so hopefully it’s easy to dig into.

Right now Aikidoka is best at nesting an existing top-level constant within another constant of a different name. I haven’t tried doing something like Aikidoka.rename("Mash" => "Mash::Twitter") or Aikidoka.rename("ActiveRecord::Base" => "ARBase"), and those examples probably wouldn’t work.

All in all, it does what I want it to and seems to work OK :) You can install it with gem install flyingmachine-aikidoka. If you’re wondering about the name, aikido is a martial art designed to resolve conflict harmoniously, and an aikidoka is a student of aikido.

Usability Embodied

2008-08-24T22:13:36Z

Usability Embodied

A few years ago I ordered DSL service. The DSL modem came with an ethernet cable, and one end was labeled “this end goes in your computer”, and the other was labeled “this end goes in the modem.” Obviously, it doesn’t matter which end goes where, but the labels undoubtedly eliminated any possible confusion.

Robots!

2008-07-14T16:45:17Z

Robots!

I’ve been learning more about electronics, in part to get a ground-up understanding of computers. In the process I’ve become interested in learning to build robots.

My first attempt at building a robot, about 8 years ago, wasn’t really successful. I was in high school and I wanted to build a robot that would turn off my light switch across the room because at night I would read in bed, and when I was done I didn’t want to have to get up to turn off the light. So I got my mom to buy me Lego Mindstorms one Christmas and put together a robot, and it would just run into the wall and fall apart. I tried a little more and kept getting the same result, so I just said “fuck it” and I bought a lamp to put beside my bed. Incidentally, that’s still how I approach problems most of the time.

Anyway, one thing I’d like to make is a little wristband with an LCD (like a digital watch) displays random words throughout the day. After that, a robot parrot which repeats words it hears often. It’ll have Barry White’s voice.

Flying Machine Studios

Abstract Mathematics and Programming

Abstract Mathematics and Programming

Machine-Aided Introspection

Machine-Aided Introspection

An Exhaustive Explanation of Minimax, a Staple AI Algorithm

An Exhaustive Explanation of Minimax, a Staple AI Algorithm

Overview

Representing Moves with the Game Tree Data Structure

Ranking Game States

Final Game States

Intermediate Game States

Ruby Example

The End… or Is It???

P.S.

A Philosophy of Programming, Rough Sketch

A Philosophy of Programming, Rough Sketch

The Processes

Learning

Memory

Naming

Metaphor

Visual Aids

Documentation

Learning Skills

Describe What You Don’t Know

Ask About it Directly

Confirm Your Knowledge

To explore

Further Reading

Why I Don't Want to Start a Startup

Why I Don’t Want to Start a Startup

Reason #1: I Don’t Want to be Like the Founders I’ve Known

Reason #2: I Don’t Think Financial Freedom is Required for Happiness

Reason #3: I Already Have Big Challenges

Thank You

Thank You

Higml: Hierarchical, Cascading, Dynamic Configuration

Higml: Hierarchical, Cascading, Dynamic Configuration

Purpose

Examples

Applying Hierarchical, Cascading Rules

Dynamic Output

Rule Application Summarized

Pronunciation

Writing Better Documentation

Writing Better Documentation

Blog Reboot

Blog Reboot

Models for Dealing with Fear

Models for Dealing with Fear

Models for Overcoming Fear

Models for Justifying Fear

World-Views Dissected

You

The Universe

Society

The Model to End All Models: Life as an Improv Game

Look Into My Eyes

Look Into My Eyes

I'm Going to Take All the Help I Can Get

I’m Going to Take All the Help I Can Get

Control Time Submitted to App Store

Control Time Submitted to App Store

How to Get and Stay Motivated

How to Get and Stay Motivated

Motivation is Your Emotional Energy for Making The Right Choices

The Anatomy of Motivation

Incentives

Confidence

Troubleshoot Your Lack of Motivation

Do you struggle with conflicting incentives?

Are your current incentives important to you?

Where are you lacking confidence?

The Best Way to Gain Confidence is to Join a Group with The Same Goals

The Why of this Site

The Why of this Site

Follow Your Followers Using Ruby

Follow Your Followers Using Ruby

Aikidoka Prevents Namespace Collisions