Zachary Pinter

Content Providers - Embrace the internet or die fighting it

2009-06-28T00:00:00-06:00

The recent cat-and-mouse games that Hulu has been fighting against Boxee and the Playstation 3 are absolutely ridiculous. One of the reasons Hulu is so popular, even when competing against free downloads, is the convenience it offers. Without that convenience, why use it over the alternatives? If content providers try to restrict how and when their content is viewed, then customers who would otherwise willing to pay (either directly or indirectly through ads) will defect to restriction-free alternatives and feel no moral hardship for doing so. However, if there is a reasonable, legally sanctioned service that has all the features and convenience required, then what is left to decide? As long as the social norm is to pay for content, people will be internally compelled to choose the legal option.

What does this mean for the television and movie industries? Well, the current generation is quite used to paying for content: they go to the movies, they rent and buy videos, and they subscribe to cable or satellite. Up until recently, these business models have remained relatively isolated since it’s fairly cumbersome and time consuming to download video content over the internet. However, that’s changing and it’s the time for content providers to change with it. Do not make the same mistakes that the music industry made. Downloading a song is now akin to driving 5 mph over the speed limit. Sure, it might be illegal, but few people think of themselves as immoral for doing so.

The new motto for the entertainment industry should be “buy once, play anywhere.” If your customers are subscribing to cable or satellite, why not give them a website to view all the same content? If a computer crashes, why not let the user redownload anything they’ve already purchased? If a customer can view a show online, why shouldn’t they be able to play it on their phone and their television set? I certainly understand and appreciate the fact that the revenues from these new mediums are far lower than existing mediums. However, there’s something far greater at stake: the ethics of the upcoming generation. Don’t let it become a question of features. Keep the focus on morality and ensure a strong customer base for generations to come.

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:

 
   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 ARRELOPGREATEREQUAL 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.