Zachary Pinter

RailsConf 2011 Recap

2011-05-21T00:00:00-06:00

RailsConf 2011 took place in Baltimore last week and I had the luck to not only attend but speak at the conference. It was my first time attending a RailsConf, and I was thoroughly impressed with the number of great talks, great after-parties, and how well-organized the conference was. Here’s the recap:

Rails Best Practices

Gregg Pollack and crew from Envy Labs opened up one of their codeschool.com courses and walked the audience through it. Each section was coupled with a video of a classic arcade game where the sound effects were replaced by hilarious vocalizations. Even if the games were only loosely related to the topic, it was a great example of capturing the audience’s attention.

The course had a healthy dose of game mechanics (a points system with hints that docked your score) and that ended up being a lot of fun. Time will tell whether learning this way sticks better than skimming blog posts.
Ignite RailsConf

Ignite ended up being a packed house with lots of great presentations. Some favorites included “How to create awesome Screencasts” and “20 Awesome Gems”
Cloud Foundry - The Rails Developer’s Perspective

Some developers seem to shy away from sponsored talks, but I really enjoyed this one. In particular, I’m interested in using Cloud Foundry as an alternative to Chef for setting up single-machine Linode instances, which I think could prove a useful middleground between rolling-your-own and the price of Heroku. The project is young, but this is definitely one to watch.
20 Productivity Tips: You Can Be 15 Percent More Productive

I met Hirotsugu Asari in the speaker lounge and he struck me as a really talented developer and genuinely nice person. His talk ended up going pretty deep into mathematical formulas, though I loved his summation: “Productivity = Number of successful Pomodori while working towards a SMART goal in a given time period”. Oh, and did I mention he has an Erdős number of 2 ?!
Why you should never use an ORM

Having played around with MongoMapper in the past, I was looking forward to John Nunemaker’s talk. The title was meant to be a little inflammatory, but it contained a lot of great points. There’s definitely value in understanding all the magic that an ORM is doing for you. Also, there’s a lot of cost and hidden complexity when trying to retro-fit an existing ORM on top of something that doesn’t really fit.
The Holy Grail of Databases

This was one of my favorite talks at the conference. There’s something to be said for speakers that talk fast and pack a lot of material in a 50 minute presentation. Eric Redmond gave a great overview of the datastore landscape and how the various datastores compare to each other, complete with sample code. Also, his seamless integration of pre-recorded coding demos had many of us wondering if he was live coding while talking! The presentation left me wanting to learn more and I can’t wait to grab a copy of his upcoming book, Seven Databases in Seven Weeks
Lessons Learned Keynote

I’ve been looking to implement a Continuous Deployment infrastructure ever since hearing Eric Reis speak about his setup at IMVU. However, working in the client services industry makes it a difficult sell to clients. This means that I only have side-projects to try it out on. I was happy to get the chance to ask Eric about bootstrapping continuous deployment with a small userbase (which makes it difficult to A/B test). While his response was not what I expected, it was a good reframing of the issue. He pointed out that having a “pathetically small number of customers” is actually an advantage since you can get to know your customers without the need for statistics. Side note: I can’t stand how my voice sounds when recorded.
Stateful, Scalable Servers with EventMachine and Rails

With all the node.js rage, it was nice to see the Ruby approach with EventMachine. You certainly have to be more careful not to make a call that blocks the event loop, but I think Ruby still wins when it comes to clean and readable code. A good example David Troy gave in this presentation was a POP server that implemented its commands as method calls, making it easy to add new commands without having to explicitly define a mapping.
Deploying with Bundler

Though I’ve been using the basic features of Bundler for some time, I appreciated this broad overview of the tool and the problems it is solving. Happily, I don’t need to deploy to servers that block internet connections, but it’s good to know they’re thinking about that stuff if the need ever arises.
Solving Performance Problems with Horizontal Scale (The Worker Pattern)

I met Ryan Smith at the Heroku booth and was looking forward to his talk. It was interesting to see the pattern he was advocating (loading a busy message in a div then polling the server until the operation is done). This pattern is quite common in Flex Apps, and I was pleased to see a straight-forward Rails-based implementation. Also, I liked his point about checking the HTTP status codes before rolling your own solution. Only downside: it was scheduled at the same time as the lightning talks, which had rave reviews.
50 in 50

Programming meets poetry. This has to be one of the strangest talks I’ve ever attended. That said, the Shakespeare videos were hilarious. I recommend watching the video, preferably with your favorite alcoholic beverage.
Building Rails Apps for the Rich Client

This was another one of my favorite talks from the conference. Yehuda gave a great presentation on the strengths of Rails over Sinatra/Rack/RollYourOwn when it comes to developing REST APIs. I tend to think Sinatra fits best for single-screen-of-code apps, and this talk further cemented the idea.
Cutting your own RubyGems

Sadly, I’ve been more of a gem consumer than creator. After hearing this talk, there’s no reason not to wrap your common code in a gem. They’ve really streamlined the process. Main takeaway: visit http://guides.rubygems.org/

RailsConf 2011 - Rails on HBase

2011-05-21T00:00:00-06:00

I was happy to give a presentation at RailsConf 2011 with Tony Hillerson titled “Rails on HBase”. We gave the talk from the position of a Rails developer interested in knowing if HBase might be a good fit for their app. The main takeaway was that unless you’re hitting the limits of your relational database, the costs of HBase will likely outweight the benefits. For more details, take a look at the slides below:

Rails on HBase

View more presentations from Tony Hillerson

Keyboard-driven Window Management in OS X

2009-06-15T00:00:00-06:00

Ever since reading about Tiling Window Managers in Linux, I’ve been looking to either switch to Ubuntu (sadly, I can’t get it to support my cinema display) or achieve a similar effect on OS X.

I posted a question to StackOverflow, which eventually led me to SizeUp. Initially, SizeUp did not support moving windows between monitors, though that has since been addressed. I found that the default key bindings interfered with Emacs and other applications, so I have mine setup as follows:

The setup is quite intuitive, as I simply hold down Command + Option along with one of the following:

| y | u | i | o | p |
    | j | k | l |
    | m | , | . |

y moves the window to the left screen
p moves the window to the right screen
k centers and maximizes the window (true maximize, not the crappy Apple maximize)
i, and , move the window to the top or bottom half of the screen
j, and l move the window to the left or right half of the screen
u, o, m, and . move the window to the corners of the screen

By matching the commands to the qwerty layout, it’s easy to remember which key combination to use.

I’m not a fan of Command+Tab for application switching (I usually have a lot of applications to choose from). Instead, I use Quicksilver/Google Quick Search to type the first few letters of the application I want to switch to. From there, I use Command + ~ to switch between the windows of the application.

Easy screenshot sharing with Dropbox and Hazel

2009-05-01T00:00:00-06:00

I often find myself using Dropbox’s public folder to share quick screenshots. This is a fairly tedious process, but it’s better than dealing with IM/firewall/vpn issues. To streamline things a bit, I recently setup a Hazel rule that automatically moves screenshots to Dropbox and copies the link to my clipboard.

To set this up for yourself, first add the Desktop folder to Hazel:

Then, setup the rule as follows:

Now, you can simply press Command+Shift+4 to take screenshots and Command+V to paste the links.

Technical Content on the eSlick Reader

2009-03-01T00:00:00-07:00

A while back Dave Thomas wrote about the state of technical content and ebooks. He provided several screenshots of a sample book on the Kindle. Sadly, the device didn’t hold up too well and it looks like version 2 isn’t much better.

The problem, at least for me, is that most of the content I would like to read on an E Ink device is in PDF format. The Kindle doesn’t natively support the display of PDFs. Instead, you have to first go through their conversion process which can clip and distort the information you’re trying to see. Other devices, like the Sony eReader, can read PDFs natively. However, the software doesn’t seem to be getting much praise. The Iliad eReader seems to have much better support, but it comes at a steep price of $700.

The eSlick Reader, on the other hand, was made for displaying PDFs. I haven’t actually seen the device, but given Foxit’s track record I have high hopes. As such, I recently emailed their support and asked them to provide some pictures of the same PDF that Dave Thomas tested with the Kindle:

As you can see, the device handles the document well. The source code doesn’t get clipped, the small text is readable, and the images look pretty decent. Now, there are some disadvantages. The device is quite basic. It doesn’t have any wireless support and the MP3 player seems like more of a gimmic than a useful addition. However, for $259 the eSlick looks like one of the best options out there for reading technical PDFs away from the computer.

Greedy Algorithms and Politics

2009-01-21T00:00:00-07:00

I’ve been a Libertarian pretty much since I’ve been able to vote. I’m for small government, free markets, and just about every personal/social liberty that doesn’t infringe on my own. However, I don’t kid myself that free market capitalism is without flaws.

At the core of free market capitalism is the idea that the market, with individuals and corporations all acting in their own best interests, will find far more optimal solutions to problems than any type of grand oversight. Furthermore, attempts to interfere with highly complex markets will usually have unintended or unforeseen side effects. While I believe this generalization to be largely true, I am reminded of a certain type of algorithm from Computer Science: The Greedy Algorithm.

Greedy algorithms are generally easy to understand, easy to parallelize, and (relatively) quick to execute. They might not always find the optimal solution to a given problem, but for many classes of problems they are the easiest way to find a close approximation. Tasks well-suited to greedy algorithms are those with an “optimal substructure.” By optimal substructure, I mean tasks that can be broken down into subcomponents where the best solutions for each subcomponent can be combined to produce the best solution for the whole. In many ways, capitalism has an optimal substructure: At each level, the incentive of wealth can drive people to create more of it. This, in turn, makes for a wealthier society, which provides more opportunity for others to create wealth. It’s a feedback loop which results in wealthier people, wealthier corporations, and wealthier countries.

However, there are problems for which a greedy algorithm is not a good fit. Consider a chess game: the capture of a queen might locally (for this move) seem like the best choice, but it could result in ultimately loosing the game. Or, consider the differences between the Elevator algorithm and the Shortest seek first algorithm. If the elevators in our buildings used shortest seek first (a greedy algorithm), then the average response time overall might very well go down, yet it would be at the expense of ignoring some floors for minutes or even hours during busy times.

If we can admit that there are problems with greedy algorithms in the computer science world, then it’s not a stretch to say there are problems with free market capitalism in the “real” world. The question is, what is the alternative?

For many, the obvious answer is government. However, government is a double-edged sword. For as much power as a government has to do good, it also has the same power to do bad. As Gerald Ford once said, “A government big enough to give you everything you want is a government big enough to take from you everything you have.” The founding fathers of the United States were well aware of this, which is why they tried to limit government. However, even if you could assume a benevolent government, you still have the problem of efficiency. As we’ve seen repeatedly, lack of competition within government makes for sloth and waste.

So, in closing, I’m a Libertarian because given the choice of government problems versus free market problems, I choose the free market. It’s not that I think free market capitalism is perfect, or even fair. It leaves a lot to be desired. However, I find that keeping the market in check with an even larger government is a much scarier proposition.

Perhaps, given this new era of technology and communication a new type of societal structure could emerge that addresses both the short-sightedness of markets as well as the sloth and size of government. Over the next few weeks I plan to speculate on the qualities such a society might have. Stay tuned!

Emacs - Great Operating System, Decent Editor

2009-01-14T00:00:00-07:00

There have been plenty of jokes made about how Emacs is more of an OS than a text editor. Over the years, the highly extensible nature of Emacs (through elisp) has led to a crazy amount of software being developed for this “text editor.” But why is that? Why in the world would somebody want a text editor slash irc chatter slash file manager slash email application?

It is my belief that the value of Emacs lies not in its ability to edit text (for which it does a pretty good job), but in how it has become the defacto framework for keyboard-based applications. You see, there’s a certain category of person that strives to optimize the mundane or common operations of their life. Programmers are especially prone to this. Languages like Ruby and Python allow one to easily write scripts that blaze through otherwise tedious problems, like renaming files. And then there’s the command line: For many tasks, such as file manipulation and ftp, far more intuitive graphical interfaces exist. However, one cannot help but love the extra time gained by using the command line equivalent.

Sadly, graphical applications tend to lack the speed (measured in user-productivity) of their text-based equivalents. Making an application keyboard-driven, if even possible, requires a large amount of effort with modern application frameworks. That’s where the beauty of Emacs comes in. Emacs is one of the few frameworks centered around keyboard navigation, primarily due to its legacy as a terminal-based text editor.

So, what are the strengths of Emacs for text-based applications?

Common metaphors (buffers, frames, windows, navigation, marking text)
Powerful scripting language
Ability to easily move data between buffers and “programs”
Ability to link to other buffers/files that are handled by other scripts/plugins

And the weaknesses?

Non-intuitive key-bindings
Carpal tunnel-inducing keystrokes
Limited graphics/drawing capability
High learning curve

Looking at Emacs from this perspective has sparked an idea. Why not make a framework specifically for keyboard-driven applications? It need not be a full-fledged text editor, but it could easily have several uses:

Thor/rake/capistrano interface
Twitter client
Blog editor
Feed Reader
Git interface
IM/IRC Client
File manager
GTD/Task manager

Now, such a project should have some high-level goals:

Easy on the wrists and fingers
Perhaps vim-like modes
Easy to learn and learns from you
- Focus on quicksilver-style auto-completions for most operations
Easy to develop for
- Use a common scripting language (ruby, python, javascript?)
- Easy rendering (perhaps webkit minus the form components?)

And the bonus features:

High Stability
Isolated processes
No single plugin/script takes down the application
Local or remote apps
- Websites could expose a markup/api that’s compatible with the framework
Accessibility
- In theory, this would be easier with an app that doesn’t rely on the mouse

So, let’s create a framework for keyboard-driven applications. Make it easy to learn, easy to develop for, and with an eye towards end-user efficiency. What do you say?

Passing arguments to Item Renderers

2008-11-27T00:00:00-07:00

When trying to create general-purpose item renderers in Flex, one of the first things I ran into was passing arguments. Passing arguments allows you to use the same item renderer in different ways.

The best solution I’ve been able to come up with is to create my own factory class:

package com.zacharypinter.util
{
   import flash.utils.Dictionary;
   
   import mx.core.IFactory;

   public class ArgumentsToRendererFactory implements IFactory
   {
      private var klass:Class;
      private var args:*;
      
      public function ArgumentsToRendererFactory(args:*,klass:Class) {
         this.args=args;
         this.klass=klass;
      }
      
      public function newInstance():*
      {
         var instance:Object = new klass;
         

         for (var key:String in args) {
            if (instance.hasOwnProperty(key)) {
               instance[key] = args[key];
            }
         }
         
         return instance;   
      }
      
   }
}

To use it, you can write something like this:

<mx:List 
   width="100%" height="100%" 
   dataProvider="{users}" 
   selectable="false" 
   itemRenderer="{new ArgumentsToRendererFactory({group:this.radioGroup},UserRenderer)}" 
/>

In the above example, I’m using the ArgumentsToRendererFactory to pass a radio group to every item renderer. This lets me use radio buttons inside a list component.

Everyday Ruby Scripting - Renaming Files

2008-08-20T00:00:00-06:00

I recently had the need to replace around 50 files. However, the new files did not have the same name as the old files.

The old files had names like: AD5001.indd AD5002.indd AD5003.indd

and the new files had names like: AD5001_rev.indd AD5002_rev.indd AD5003_rev.indd

The solution was a quick ruby script:

require 'fileutils'
rev_files = Dir.glob("./**/*_rev*.indd")
    
rev_files.each do |rf|
  orig_file = rf.gsub("_rev","")
  FileUtils.rm(orig_file)
  FileUtils.mv(rf,orig_file)
  puts "Replaced #{orig_file} with #{rf}"
end

Originally, I was going to use some combination of Emacs and find-dired, but ultimately this proved simpler.

301 Redirects in Rails

2008-07-25T00:00:00-06:00

If you’ve ever searched for how to do a 301 redirect in Rails, you’ve probably seen this code:

headers["Status"] = "301 Moved Permanently"
redirect_to "http://www.domain.com/"

However, after doing some testing (thanks rspec!), I found that the above snippet does not work. Instead, it sends a 302 temporary redirect, which, of course, has an entirely different meaning for the search engines visiting your site.

Apparently, somewhere along the way, Rails stopped honoring the explicit Status header when using redirect_to. To achieve the correct result, you must now use:

head :moved_permanently, :location => "http://www.domain.com/"

To make things nicer, I added the following function to my application.rb file:

def perm_redirect_to(options)
   url = case options
         when String
           options
         else
           url_for(options)
        e end
   head :moved_permanently, :location => url
end

Weak References with Dictionaries in Actionscript

2007-10-11T00:00:00-06:00

Actionscript dictionaries are a great tool for dealing with memory management because you can use them to create weak references to objects. This means that the object automatically goes away upon garbage collection if the only reference to it is in the Dictionary.

To use a dictionary in this manner, simply pass true to the constructor. However, one should note that this only makes the keys of the Dictionary weak.

For example:

class MyObject {
  public var message:String;
}

var dict:Dictionary = new Dictionary(true);
var obj1:MyObject = new MyObject();
    
obj1.message = "My really long message...";
var obj2:MyObject = new MyObject();
obj2.message = "My second really long message...";

dict[obj1] = true; // obj1 is weakly referenced
dict[2] = obj2; // obj2 is strongly referenced

If the only reference to an object is the key of a weakly referenced dictionary, the object will not persist after garbage collection. However, if the only reference to an object is the value of a key in a weakly referenced dictionary, the reference is considered strong and will force the object to persist after garbage collection.

So, what do you do if you want to store a dictionary of weakly referenced objects, but key them off of a meaningful value (such as an item id) rather than their reference id?

The answer is to use a simple WeakReference class source:

class WeakRef {
  private var dic:Dictionary;
		
  public function WeakRef(obj:*):void {
    dic = new Dictionary( true );
    dic[obj] = 1;
  }
		
  public function get():* {
    for( var item:* in dic ) {
      return item;
    }
    return null;
  }
}

From here, you can do the following:

var dict:Dictionary = new Dictionary(true);
var obj1:MyObject = new MyObject();

obj1.message = "My really long message...";
var obj2:MyObject = new MyObject();
obj2.message = "My second really long message...";

dict[1] = new WeakReference(obj1); //weakly referenced value
dict[2] = new WeakReference(obj2); //weakly referenced value

Now, you can key based off of a meaningful value, and still get all the benefits of weak references.

Actionscript Hash

2007-10-09T00:00:00-06:00

On the surface, the Dictionary object in Actionscript seems quite limited compared to the Hash and HashMap libraries of other languages. However, the functionality you would expect is still there, it’s just obscure.

For example, to loop through all keys in a Dictionary:

for (var key:Object in groupMap)
{
   trace(key + ", " + groupMap[key]);
}

To loop through all values in a Dictionary:

for each (var item:Object in groupMap)
{
   trace(item);
}

To check if a key exists (in a way that’s distinguishes from a key whose value could be null):

obj['key'] === undefined  //key exists

To remove a key/value pair from a Dictionary:

delete obj['key']

All of the above code will also work for a regular object treated like a hash.

What are Ruby Symbols?

2005-12-12T00:00:00-07:00

I’ve introduced a few friends/classmates/coworkers to Ruby and Rails lately, and many of them have since approached me and asked “what is that colon thing in ruby?” So, I’ve decided to explain Ruby symbols as I know them.

Symbols are essentially small, automatically created global read-only objects that have a unique numerical value associated with them and are accessed through the :[name] syntax. Any time you use a named symbol (such as :bob), you are really telling Ruby to find the object associated with the name “bob” in the global table of symbols. Therefore, :bob in one class returns exactly the same object that :bob returns in another class.

The numerical value associated with a symbol object is generated for you behind the scenes. You don’t really care what it is, you just care that it is unique among all other symbols.

This nature of symbol objects creates some very useful applications. For one, you can use a symbol as a named constant whose value you do not care about. For instance, you might have a C library with tons of interesting constants like AR_REL_OP_GREATER_EQUAL = 3 For the sake of C programming, that constant has to have a value. However, if all you really care about is whether or not something is flagged as AR_REL_OP_GREATER_EQUAL, then the actual value is practically meaningless. In such a case with Ruby, you could use symbols to write code like

if x.operation == :greater_equal
   #...
end

You can check whether or not a value equals :greater_equal without ever having to select a numerical value for :greater_equal. As an added bonus, you can call :greater_equal.to_s and get a full-blown String object out of the name of the Symbol. Now, that might not seem like a big deal just now, but think about converting AR_REL_OP_GREATER_EQUAL into a cstring. With symbols, it’s a piece of cake, and there are plenty of times when finding the actual name of a constant is useful, especially when it comes to debugging.

Since the actual object that is referenced by a symbol is global and unchangeable, it makes a perfect candidate for use as a key in a hash table. That is why you always see syntax such as:

{:name => "Zachary",:job => "Programmer"}

The above code is short-hand syntax for creating a Hash object with the keys :name and :job mapped to the values “Zachary” and “Programmer”. Yes, one can always use String objects as keys in a Hash, but in Ruby, a String object is changeable (mutable). For example, you can call gsub! on a String and replace the contents of the object. Doing so would change the value that the String would hash to, and corrupt any Hash table that String was used as a key in.

If you’re a Java programmer, you should note this very important difference between a Ruby String and a Java String. In Java, String objects are unchangeable (immutable) and StringBuffers are changeable (mutable). In Ruby, Symbol objects are unchangeable and String objects are changeable. When you call concat (”+”) or replace on a Java String, you are actualy creating a brand new String object (instead of making changes to the current one). This is precisely why Java programmers are told to use a StringBuffer class instead of the ”+” sign to concatenate several strings. In Ruby, no concern is paid to concatenation, since the core String class is mutable. Similarly, in Java, it is common to use a String object as a key in a HashMap. In Ruby, that’s frowned upon since a lot of things could go wrong if that String object were changed (as explained above).

Symbols may seem awkward at first because they are not common among other programming languages. However, there are many pro’s to the tradeoff made by choosing String/Symbol (Ruby) over StringBuffer/String (Java). Additionally, the unique nature of symbols has it’s own benefits when it comes to flags that were traditionally set with numerical constants.