Don’t get me wrong, I hate Comcast’s stupid approach to file sharing. But adding unlegislated regulation isn’t my idea of a solution. I’d still like to think that our free market-driven economy will take care of open, equal internet access for all. The real problem, if there is one, is for consumers who don’t have any broadband alternative to Comcast. But as DSL access spreads to the uttermost, I find myself agreeing with the telco’s: Net Neutrality is a solution in search of a problem.

Source: http://biz.yahoo.com/ap/080711/internet_regulation.html?.v=5

I have received some contributed monkeys: today we’ll look at Ruby Monkey and Python Monkey.

Ruby Monkey

Ruby monkey quite arguably ought to have been included in the first troop of monkeys. “Ruby” is the word most likely to follow the word “like” when Groovy programmers are talking about Groovy to programmers who have never heard of Groovy. Ruby is Payton Manning to Groovy’s Eli. So without further ado, here is the Ruby Monkey contributed by Jason Felice:

monkey = Monkey.new
monkey.see.each{ |action| monkey.do action }

This monkey is quite similar to the Groovy Monkey, but of course there are some differences. Let’s anglicize this gem of a primate:

Monkey is monkey new.
Monkey see each action, monkey do action.

I’ll admit I may have taken a little poetic license with the placement of the comma in the second line, but I think it was worth it. This is eminently comprehensible as English. In fact I’d have to say this monkey edges past the Groovy monkey and vies with the Perl monkey for the title of Most Lucid Monkey.

Ruby Monkey Guts

Jason’s implementation of this monkey is very similar to the Groovy and Perl monkeys:

class Monkey
  def see
    ["scratch", "climb", "eat banana"]
  end
  def do(action)
    print "Monkey does #{action}\n"
  end
end

All in all, very nice. Of course Ruby monkeys have another nice feature: they can be taught! Let’s teach Jason’s Ruby monkey a new trick. Take a bow, monkey!

class Monkey
def bow
    print "Monkey takes a bow\n"
  end
end

monkey.bow

Python Monkey

This monkey was contributed by Bob Griffin.

monkey = Monkey('lulubelle')
[ monkey.do(action) for action in monkey.see() ]

Bob informs me that “monkey” is one of his favorite variable names. He uses “monkey” when other programmers cling stubbornly to “foo.” He also apparently prefers his monkeys to have names. So let’s see how Lulubelle sounds in English:

Monkey is monkey Lulubelle.
Monkey do action for action in monkey see.

Wow! That’s a totally different grammatical formulation! It almost sounds something like “Monkey does what monkey sees.” Obviously, Lulu marches to the beat of a different drum, preferring not to ape her counterparts from other languages.

Python Monkey Guts

class Monkey:
  name = ''
  def __init__(self, name):
    self.name = name
  def action(self, verb):
    print self.name + ' ' + verb
  def eat(self):
    self.action('eats')

  def sleep(self):
    self.action('sleeps')

  def scratch(self):
    self.action('scratches')

  def see(self):
    #array returns functions not strings
    return [self.eat, self.sleep, self.scratch]

  def do(self,fn):
    #functions are passed as 1st class variables and then run
    #Notice ’self’ does not need to be prefixed as the address of
    #the monkey instance’s function was passed
    fn()

This Python Monkey seems pretty verbose. This is partly because she has distinct methods for each of the things that the Monkey can see. But notice the difference this makes possible: other monkeys are technically seeing strings which represent actions. It’s almost more like “monkey read, monkey do.” But this Python Monkey sees methods; so Lulubelle is literally “seeing” the action which she then does herself.

Python monkeys obviously have a unique take on solving problems. Some say they can’t adhere to a spec. But Python Monkeys generally have a clear objective in mind, and they end up with some very interesting results.

Stay tuned: Jason’s Haskell Monkey and Scheme Monkey are up next!

English Monkey

Whenever a monkey sees an action, he does the same.

Short, sweet and to the point. This English monkey will be our baseline for evaluating the lucidity of other monkeys. Note the basic parts of this program:

• the declaration (”…a monkey…”)
• the iterative loop (”Whenever…”)
• the set being iterated upon (”…sees an action…”)
• the operation for each iteration (…does..)

Also note the use of pronoun (”he”) and reference (”same”). Clearly English is a language which has and relies upon a sophisticated sense of context.

Groovy Monkey

def monkey = new Monkey()
monkey.see().each { monkey.does(it) }

Nice. This Groovy program almost reads like English. In fact, let’s transliterate it to English:

Def monkey is new monkey. Monkey see each, monkey does it.

That’s downright comprehensible! I like Groovy’s use of the pronoun it. That’s very English-ish. I’m not sure “Def monkey” really does make sense, but it sounds kinda urban and hip.

Perl Monkey

my $monkey = new Monkey;
for ($monkey->see) { $monkey->do($_); }

The Perl monkey program is similarly terse, and arguably even more lucid than the Groovy version (assuming you can get past all those crazy sigils!). Let’s transliterate into English:

My monkey is new monkey. For monkey see, monkey do.

Whoa, that is catchy! That terribly punchy ending is made possible, in part, by the fact that Perl lets us reuse the “do” keyword, whereas Groovy does not (nor does Java). On the other hand, that pronoun “$_” really doesn’t have a comprehensible English counterpart. Happily the power of English expression leaves the whole thing perfectly lucid if we simply drop it.

Also, note the possessiveness in this program: it’s not just any monkey, it’s my monkey. Perl monkey implementers quickly learn to label everything that belongs to them so that other Perl monkeys don’t come in and just grab and use them as global variables.

Java Monkey

import java.util.ListIterator;

Monkey monkey = new Monkey();
ListIterator see = monkey.see().listIterator();
while (see.hasNext()) { monkey.does(see.next()); }

I’ll say this: Java monkeys leave nothing to chance. For this program I’ve chosen to bring in a useful tool. Some would say that the fact that Java monkeys use tools early and often is a mark of their intelligence. But in this case it just means that using a tool seemed a lot easier than writing the program with the stuff which comprises the Java language itself.

But how does it sound transliterated into English? Kinda like Vogon poetry:

Import java util list iterator.
Monkey monkey is new monkey.
List iterator see is monkey see list iterator.
While see has next, monkey does see next.

What kind of creature could listen to that and not be wracked with pain? It’s florid, murky, and verbose. Sometimes it’s downright misleading! And I could almost endure all of that if not for the occasional use of catchy alliteration which makes it seem like the author is actually saying something meaningful, stomped out in a tribal tattoo: “monkey monkey is new monkey.”

Far from using any sense of context, Java monkeys must eschew pronouns, and must often overstate matters, repeating themselves for emphasis: “list iterator see is monkey see list iterator.” I like programming in Java, but when I see it in English, I have to admit it’s absolutely horrible.

How To Implement a Monkey

Obviously each of the above examples assumes that all participants in the context know what a monkey is and where to get one. Without that knowledge, none of them will work. So let’s not just fling.do() at all that messy complexity. Let’s see what it looks like to get an actual monkey in each of these languages.

English Monkey Guts

Don’t make a monkey of yourself. Instead, go to a reliable supplier of monkeys such as a rainforest, zoo or monkey farm, and pick out a nice monkey. Preferably the monkey should be intelligent enough to be trained, but not so intelligent that he innovates. He should have all the normal faculties typical to monkeys in good working order (in particular, eyes, hands, limbs, etc.).

Nobody’s going to argue that English has no expressive power. In fact it’s the baseline for expressiveness for this experiment. But as with many expressive languages, with great power comes great responsibility. While it may seem that the English monkey completely flubs the terseness test, bear in mind that it is far more difficult to get a monkey using English than it is in most computer languages. And as the program itself powerfully implies, making a monkey using English is practically impossible.

Groovy Monkey Guts

class Monkey {
    def see() {
        ["scratch", "climb", "eat banana"]
    }
    def do = {
        println "Monkey does ${it}"
    }
}

Once nice thing about (most) programming languages is the ability to create highly specialized monkeys, designed for specific functionality and which therefore omit many of the behaviors commonly associated with monkeys. An English monkey almost always has other methods, traits, and event handlers that aren’t pertinent to whatever it is you’re trying to get the monkey to do. It gets to the point that when you ask an English monkey to do something, you don’t know what’s going to happen.

But this monkey is a Groovy monkey, and only really does two things: he can see, and he does.

Perl Monkey Guts

package Monkey;

sub new {
    bless {}, shift;
}
sub see {
    ("scratch", "climb", "eat banana");
}
sub do {
    $self = shift;
    print "Monkey does $@_[0]\n";
}

The Perl monkey, like the Groovy one, is far more concise and focused than the English monkey. However, he isn’t quite as terse as the Groovy monkey. The Groovy monkey has an implicit sense of self identity; his identity comes from the Groovy language itself. The Perl monkey, on the other hand, finds it necessary to explicitly define himself (and as we discussed above, what belongs to him). Without a blessed reference to himself, he’s nothing more than a heap of monkey parts –any of which could be directly utilized by other monkeys, but you couldn’t really say that the monkey was doing things himself, because in Perl, without a “$self”, there really is no monkey to speak of.

So it would seem that Perl does not provide its monkeys with a sense of identity the way other programming languages do. Perl monkey implementers often regard this as a positive feature, however, since they tend to be fiercely independent and often identify themselves with more than one language in any case.

Java Monkey Guts

import java.util.ArrayList;

public class Monkey {
    public ArrayList see() {
        ArrayList see = new ArrayList();
        see.add(”scratch”);
        see.add(”climb”);
        see.add(”eat banana”);
        return see;
    }
    public void does(String action) {
       System.out.println(”Monkey does ” + action);
    }
}

Again we see that Java monkeys like everything spelled out in triplicate, and they often bring in extra tools sooner than the monkeys of other languages would need to do. But I think that the Java monkey’s psychological profile predisposes him to like this arrangement. He doesn’t really mind that his language is so far from English. After all, look at the English implementation of a monkey above: who really wants that kind of bloated, buggy monkey? You practically have to document usage guidelines and installation instructions right in the source code!

The irony here, of course is that Java is as vague when written in English as English ever was from Java’s perspective. I really do think that Java was invented by aliens with a signed permit to demolish the planet.

What does a monkey look like in your native tongue? I have a friend pondering what a Haskell monkey would look like. But I’d also really love to see your ideas for others, such as a Python Monkey, a Ruby Monkey, an Arc Monkey. How about a Basic Monkey? Is that even a meaningful concept?

In any case if you have an example of a monkey in any other idiom, please send it (or its URL) to me at joel ~at~ clickherder dot com; I’d love to include it and compare it to the above examples.

So imagine my shock and horror this morning when I sat down to read email this morning, and discovered my usually stuffed inbox had only four emails in it.  I immediately started scanning for stories of the same.  There were some stories out there, however, none were all that current.  Could my account have been singled out as having violated some obscure policy?  There was no notice from Google to indicate any such thing.

The cause of this deletion scare began to come clear as I was reading through some of the labels which still had emails.  In fact I noticed that all my labels still contained their emails.  And then I noticed that all the emails I was seeing had acquired a label which would not ordinarily apply.  I checked that label, and found, sure enough, all my emails were there.  It was starting to look like a filter problem.

After looking over the filter which labeled and archived my tech-related newsletters, I did some experimenting around and discovered a quirk: in certain situations, Gmail recognizes the minus sign as a special character which signifies negation, i.e. “NOT”.  This makes perfect sense if you want to create a filter for all emails except those from bob@example.com.

Note the “Also apply” checkbox for this filter:

You have to be careful once you decide to negate more than one email in the “From” criteria, of course.  Since an email can only be from one sender, any filter which negates two patterns joined by an “OR” will automatically catch all emails.

This, however, is not the gotcha which got my inbox cleared.  What got me was a minus sign in conjunction with a wildcard.  Let’s say that you get several email newsletter from the Bar Company.  For whatever, reason, they send you emails from multiple domains: announcements@foo-bar.tld and deals@baz-bar.tld.  My problematic pattern was something like this:

So apparently Gmail’s filters are interpreting *-bar.tld exactly the same way it would interpret -*bar.tld, which is to say, “match everything which is NOT like *bar.tld right?  Wrong.  When I tried the pattern below,

I got another surprising result:

So in English, “match anything which does NOT match *bar.tld“.  In my inbox, that would be all emails.  Yet this pattern matches none of them.  Weird.

In any case I’m glad all my email wasn’t actually deleted. 

Powered by ScribeFire.

We’re already at the point that people who do RSS aggregation well (i.e. manage their attention economies) will start to pull ahead of the pack in terms of being well informed and in terms of having a good comprehension of the web 2.0 marketplace in general. Fading is the conception of the web as a library of searchable information; the concept now is of the web as a constant flow of new information across the individual user’s desk (or lap, or palm).

Found via Read/Write Web: Lifestrea.ms Is Attempting to Build the Future of Life Online.

What’s cooking at Rouxbe, the Gurus of Guruji, plus dead men tell no Clicktales. The Helblings are back after hiatus.

The Helblings talk about Facebook’s “The Platform”, Microsoft scratching the Surface, and Mahalo trying to find its butt with both hands.

The Helblings are not talking about Google this time. Instead its would-be Google killer Ask.com, recent Google aquisition Feedburner.com, and cinalytics site TapeFailure.com.