Brian Amerige – Some Praise to the Developer of Flow

In this blog post I’m going to give praise to Brian Ameriage, the developer of the Flow FTP Program available for Mac OS X Leopard. I’ll quickly go through some of the ways that Brian has impressed me over the short time I have known him over the web.

1 Flow

I was involved in the Beta testing of Flow for a few months and as expected I ran into some problems. There was one, rather complicated problem that I decided to send in a bug report regarding. As a developer myself I knew what a good bug report would look like. I started from scratch, listed the steps to produce the bug (100%), etc. To my surprise I got a great personalized response:

Joe,

These issues should all be cleared up in Beta 5 (not yet released.) Keep in mind, though, that the issues you are experiencing are likely related to keychain, however, so it’s worth a shot remove all of your bookmarks, and to open up Keychain Access and remove any bookmarks tagged with “ConnectionKit Password.”

Thanks for the detailed report :-)


Thanks,
Extendmac, LLC.

Not only did he say that it was fixed in the next release, but he gave an indication as to what the problem was, a possible workaround, and appreciation for the report. From that point on I was sold on Flow. I continued to submit bug reports and they were all answered quickly, from a few hours to a few days after submitting them. They were all eventually resolved, and sometimes under extreme conditions. Did anyone ever wonder why there was such a quick jump between Beta 7 and 7.1 (or was it 8)? Turns out Brian stayed up past 2:30 AM hammering out some bug fixes.

2 Passion and Dedication

I think Brian’s most recent blog post, Arrogance in Engineering sheds some light on this topic: (my emphasis)

There’s a tremendous difference between an engineer on paper and an honest-to-the-bone engineer. The great kind are tinkerers. They build things in their spare time and are positively eccentric about it.

Passionate developers do the best work because they are always thinking about how they can improve things. Developing, Engineering, etc. its not a 9-5 job… its an ongoing, never-ending, adventure to improve, innovate, and create. For a number of people perfection is not a goal, its the standard. I sensed this quality in the way that Brian handled himself developing Flow, supporting it, collecting critical feedback, and keeping patient by not releasing it before it was ready.

The release of Flow has been a great success. I saw minor improvements made over the last few weeks, and even hours before the launch (I was in email contact late that night) where Brian’s attention to detail, aim for excellence, and dedication really stood out.

3 Finally, Composure

Composure is very different then Passion. The combination of the two characteristics is rare, but its something that I saw in Brian. Its especially something that I saw in a number of Brian’s blog articles (some of which I think have been lost). I remember seeing the blog posts and realizing the thought with which he put into his reasoning and his supporting arguments; knowing that what he was saying might not be the idea of the majority. Blogs are often just diaries, outlets for emotion, but those can easily be confused with rants. Either by design or not, Brian’s blog had reason and logic far beyond his years.

Brian who?

To steal a little content from Brian’s website, here is a just a small portion from his Bio:

  1. In that sense, I design how software works. That encompasses engineering the architecture, writing the code, and illustrating the interface, but more importantly, thinking about how people will use it.
  2. It’s not about technology, it’s about what it does. My passion is making tools for people.
  3. I’m 17 years old. (And yes, I’m both embarrassed and depressed by the behavior of most people my age.)

There are Others

People like Brian are not a dime a dozen. I’ll admit he is one of my mini-heros. There are plenty others, who’s names I’ll leave out in the hope that I can contribute an entire article to them as well. But I figured I’d swallow a little of my own medicine. Now I better get back to writing some real programming on this blog before all my readers get confused!

You deserve it, Keep up the great work.
– Joe P

Give Some Appreciation

I have had the idea to write this article for a long time. But this morning I came across Allan Branch’s blog post titled “It isn’t always about you…” containing the following message:

I read many blogs and follow or have followed a number of people on twitter. I think I see a trend in both, rarely does anyone talk about others in a light that takes the spotlight off of themselves. Most people are so worried about their own personal glory and fame they cannot show real praise to anyone but themselves in fear of losing a grasp of their “fame.” They only talk about their thoughts, their ideas, their apps etc. These people aren’t evil, they’re usually great people.

I want to spin this and instead give you ideas about why and maybe even how you should give some appreciation to your “mini-heros.” Don’t worry, this article has an extreme amount of “I” statements, but I (there’s one) really think that this blog post contains my thoughts and I hope you get the chance to read it.

Mini-heros

You should have a list of individuals that you think have passion, present themselves in a model way, are helpful… the list of good characteristics are nearly endless. The essential idea is that they have had some impact on you or possessed some notable quality that impressed you. In some cases, for professions and hobbies you may have a mini-hero that gives you pride in being a part of that activity, hope in its future, and make it even more enjoyable. These people, are the mini-heros.

I think in the end, these role models and mini-heros, lack feedback and recognition and don’t realize how important and influential they really are. More and more frequently I am remembering the names of individuals that make an impact on me, from as important as my career to as nuanced as my hobbies.

Where am I going with this?

I want you to just write out a thank you letter, a blog post, maybe even a donation… offer some appreciation to someone who made an impact on you. If you can’t think of anything now, then just keep your eye out in the future for that small app that really impresses you and maybe the developer was kind enough to help you out.

A Non-Generic “Thank You” Means So Much More

Qualify your thank you with a reference to what the person did that really impressed you. Take the time to reword a “Thank You” to “Thanks for spending the time to look at this. I really appreciate your help.” Point out what it is the person did that was extraordinary or separated them from the norm. Personally, I make sure that I mean every “Thank You” that I say, and I try to say it in such a way that they know I’m thankful. Its a shame that there is such a thing as an empty Thank You, but it does exist. Those two words don’t nearly have the meaning they used to. So if you make them mean something, they will be far more appreciated.

Keep in mind blubbering flattery or worship is not what I’m asking. People appreciate praise more from their peers and equals or from people who are “above” them (I’m thinking bosses, managers, etc.). I’ll leave with the following article by Neil Patel that I feel carries some truth on How to Build Influential Relationships. If you read that article I want you to keep in mine that its not always necessary to build “influential” relationships; a simple letter of praise, with good reason, is always appreciated.

Dot Files For Your Shell and Even Ruby

I have come across a number of programmers who don’t know what dotfiles are. Thats a shame. Every programmer should know common dotfiles and actively seek to add aliases, functions, and other tidbits to increase their productivity and make the shell more usable. I recently went on a binge and updated a few of my dotfiles. I’ll share some useful tricks that I found on not only my ~/.bashrc file but also ~/.irbrc for my ruby IRB prompt!

I won’t show off my entire ~/.bashrc file, only because it is rather long. I just want to get across some of the usefulness of such a file:

# -----------
#   General
# -----------
alias ..='cd ..'
alias ll='ls -lh'
alias la='ls -la'
alias ps='ps -ax'
alias du='du -hc'
alias cd..='cd ..'
alias more='less'
alias mkdir='mkdir -p'
alias today='date +"%A, %B %d, %Y"'
alias yest='date -v-1d +"%A %B %d, %Y"'
alias recent='ls -lAt | head'
alias ebashrc='mate ~/.bashrc'
alias mbashrc='mate ~/.bashrc'
alias sbashrc='source ~/.bashrc'
alias htdocs='cd /Applications/MAMP/htdocs/'
alias mampmysql='/Applications/MAMP/Library/bin/mysql -u XXXXX -p'
alias desktoptopia='open /Users/joe/Library/Application\ Support/Desktoptopia/.Backgrounds/'
alias ql='qlmanage -p "$@" >& /dev/null' # Quick Look alias

# -------------
#   Shortcuts
# -------------
alias c="clear"
alias m="mate"

# --------
#   SSHs
# --------
alias rit="ssh holly.cs.rit.edu -l XXXXX"
alias vega="ssh vega.it.rit.edu -l XXXXX"

# -------
#   Git
# -------
alias ga='git add'
alias gs='git status'
alias gd='git diff'
alias github="open \`git config -l | grep 'remote.origin.url' | sed -En 's/remote.origin.url=git(@|:\/\/)github.com(:|\/)(.+)\/(.+).git/https:\/\/github.com\/\3\/\4/p'\`"

# --------
#   Ruby
# --------
alias irb='irb -r irb/completion -rubygems'

# ---------------
#   Environment
# ---------------
export PATH="$PATH:/usr/local/bin:/usr/local/sbin:/usr/local/mysql/bin"
export PATH="$HOME/bin/:$PATH"
export HISTSIZE=10000
export HISTFILESIZE=10000
export PAGER=less
export CLICOLOR=1
export EDITOR="/usr/bin/mate -w"

Hopefully this wasn’t too overwhelming. But lets take a look at some of these. There are a bunch of aliases at the top which simply replace the older version? It just makes sense that when you do a ps you really want `ps -ax`. Likewise a few others there are printing disk usage with human readable output.

Nothing completely interesting however everything is extremely useful. I’m cutting my keystrokes in half and getting better output. I have a bunch of more exciting tricks in the rest of my ~/.bashrc. Its not just reserved for aliases and EXPORTS, take this function for example:

# cd directly to a dir and list contents
cdl() {
  if [ "$1" ]
  then builtin cd "$1" && ll
  else builtin cd && ll
  fi
}

Cd to a directory and list the directory. I even reference my ll alias up above to list long. You can take a peek at my entire .bashrc file on dotfiles.org. Lets move on to something you may not have known about. Let me walk you through parts of a nice ~/.irbrc file, which you might want for yourself:

# Load and Start Wirble, a gem to beautify irb
require 'wirble'
Wirble.init
Wirble.colorize

Probably one of the most popular inclusions in a .irbrc file. Wirble is a Ruby gem built for improving the irb interactive ruby console. That means you may also have to ‘require “rubygems”‘ in order for this to work. Take a look at the gem documentation for Wirble to find out more of its capabilities. But that also means you can include a number of other useful rubygems. For instance, what_methods, map_by_method, hpricot, yaml, the list goes on and on. Instead I’m going to point out some other neat additions you can add to your .irbrc!

# Awesome benchmarking function
# Source: http://ozmm.org/posts/time_in_irb.html
def time(times=1)
  require "benchmark"
  ret = nil
  Benchmark.bm { |x| x.report { times.times { ret = yield } } }
  ret
end
alias bench time

# A cool way to index in a hash
# h = { :alpha => 'bet', :beta => 'blocker' }
# h/:beta #=> 'blocker'
class Hash
  def /(key)
    self[key]
  end
end

# Simple regular expression helper
# show_regexp - stolen from the pickaxe
def show_regexp(a, re)
  if a =~ re
    "#{$`}<<#{$&}>>#{$'}"
  else
    "no match"
  end
end

# Convenience method on Regexp so you can do
# /an/.show_match("banana") # => "b<>ana"
class Regexp
  def show_match(a)
    show_regexp(a, self)
  end
end

There, now you’re building some really useful tricks! Check it out. Thanks to a few different sources for those code snippets I can easily benchmark any code run at any number of times. There is a neat way to pull an element from a hash, without having to put [brackets] around the key. Finally, a little helper for regular expressions which is useful every now and then.

But wait, there is more. This time a little more system specific:

# Textmate helper
# Source: http://dotfiles.org/~lattice/.irbrc
def mate *args
  flattened_args = args.map {|arg| "\"#{arg.to_s}\""}.join ' '
  `mate #{flattened_args}`
  nil
end

# Clear
def c
  system('clear')
end

You can now open up TextMate from within irb! I’ve also grown so used to using my ‘c’ alias to clear the terminal prompt that I added the same functionality to irb. Just make sure that you don’t name a variable c!

Now let me blow your mind:

# Why's aorta method to edit an object in YAML, awesome!
# Source: http://rubyforge.org/snippet/detail.php?type=snippet&id=22
require 'yaml'
def aorta( obj )
  tempfile = File.join('/tmp',"yobj_#{ Time.now.to_i }")
  File.open( tempfile, 'w' ) { |f| f << obj.to_yaml }
  system( "#{ ENV['EDITOR'] || 'vi' } #{ tempfile }" )
  return obj unless File.exists?( tempfile )
  content = YAML::load( File.open( tempfile ) )
  File.delete( tempfile )
  content
end

Why is a famous member of the Ruby community. This function here actually takes a Ruby object, exports it as YAML to a file, opens the File for editing, and once saved reloads the file from YAML. Essentially it allows you to edit the contents of an object in YAML. Absolutely amazing, let that stir in your mind for a minute!

Now, I have started building my own library of functions that I have deemed semi-useful but not worthy of turning into a gem. These functions include some simple String extensions like my TXT helpers. I include all these files in a directory and I auto-load them like so:

# Load all my non-test libraries in '~/.util/irb'
util_dir = File.expand_path('~') + '/.util/irb/*'
Dir[util_dir].each do |f|
  require f unless File.basename(f) =~ /\Atest/
end

Notice how I ignore any files starting with “test”. I have gotten into the habit of creating test files for my libraries and the naming convention I use is the exact same as the majority of Ruby developers, you just create a new file called “test_library.rb” to test “library.rb”. Simple yes, and helpful in this case where I want to avoid loading these test files. This means I have all my useful functions pre-loaded whenever I open the irb. I’d like to see what additional stuff you have!

Finally here are links directly to my .bashrc and .irbrc files. Enjoy, and please give me additions!

Ruby Can Help you TXT

I’ve never been a “Txter.” I’d much rather call my friends or have them call me. Its a pain to have to search for this small letters, push keys 1-4 times, search for shift, etc. Its a pain ever time I have to text. Hopefully this will be completely avoided as I consider replacing my iPod Touch with an iPhone this coming week after the WWDC Keynote. Either way I decided to employee Ruby to help me out.

It all started with a simple function to convert phone numbers with letters to their numbered equivalent. For instance converting “555-HELP” to “555-4375” like so:

# Extend the String Class
class String
  
  # Converts a phone number with letters to numbers
  # Ex. AAA-FFFF => 222-3333
  def convert_to_phone_number
    letters = 'abcdefghijklmnopqrstuvwxyz'
    numbers = '22233344455566677778889999'
    self.downcase.tr(letters, numbers)
  end
  
end

puts "555-HELP".convert_to_phone_number # => 555-4357

I decided to take it a step further. Why don’t I have Ruby tell me what I should push to text a string? So with a few modifications, and some studying of my cellphone I came up with the following function, also extending the String class (not shown):


  # Converts the given string to the sequence of
  # numbers that you would need to push to create
  # that string. Shift = *, Space = #
  # Input: "Hello hi"
  # Output: "*44 33 555 555 666 # 44 444"
  def how_to_text
    letters    = 'abcdefghijklmnopqrstuvwxyz '
    numbers    = '22233344455566677778889999#'
    multiplier = '123123123123123123412312341'
    str = ''
    self.each_byte do |char|
      char = char.chr      
      if char =~ /[A-Z]/
        str += '*'
        char.downcase!
      end
      str += if letters.include? char
        index = letters.index(char)
        numbers[index].chr * multiplier[index].chr.to_i
      else
        char
      end + " "
    end
    str.chop
  end
  
  # Converts the given numeric sequence back to
  # a text string.
  # Input: "*44 33 555 555 666 # 44 444"
  # Output: "Hello hi"
  def decode_text
    letters = 'abcdefghijklmnopqrstuvwxyz '
    numbers = '22233344455566677778889999#'
    str = ''
    self.split.each do |part|
      shift = part[0].eql?(?*) ? true : false
      part = part[1,part.length] if shift
      pos = numbers.index(part) + (part.length-1)
      str += if shift
        letters[pos].chr.upcase
      else
        letters[pos].chr
      end
    end
    str
  end

Texting is no longer a burden. I even have a decode function to convert back from the cryptic pattern to its original string. Right now the function is limited to typing lowercase letters, uppercase letters, and spaces. I might spend the time to abstract this even more so you can pass in your phone’s texting “model”, a String/Hash/Object providing such information, and it would use that to generate the keystrokes required to text. For now I’m pleased with what I have.

>> "until next time".how_to_text
# => "88 66 8 444 555 # 66 33 99 8 # 8 444 6 33"  

I use tab-autocompletion in my IRB and I load this library from my ~/.irbrc, but if you are really interested you could alias how_to_text to how_to_txt to make it a little more fun. That makes it a little harder on tab-autocompletion though.

Feel free to download and improve it. I’ll keep it out of my GitHub for now and just store it in my free directory:
Download
Test Case

search