Introducing Dynamo BI

For those who were concerned about the fate of LucidDB after the downfall of LucidEra (and who enjoyed the picture of the Black Knight spurting blood post-amputation), well, have you ever heard about how starfish can grow their limbs back? Click on this image for an update...



Here's the official announcement. Oh, and also, LucidDB v0.9.2 has left the building! Have fun kids...

Four Legs Good, Two Legs Better

Vertica does Map/Reduce.

I Should Really Get a Job Soon

So, omegle has been providing amusement for a while; time for some man-in-the-middle hijinks. The Perl script below opens up two connections and relays the messages between the two, but also prints them out for you voyeuristic sickos out there to eavesdrop on. It doesn't try to mimic the "Stranger is typing..." notifications, but the average omegle user doesn't seem to pick up on that.

Note: most likely this has already been done many times by others--it's just too much of an easy target.

You'll need the WWW::Omegle package installed in order to use the script; after installing with cpan, I also tweaked a few places to suppress warnings about new notifications it didn't understand yet. Can you tell I don't actually know Perl?

If you want to have more fun, you can make it say initial messages to each side (I used "peanut butter?" and "chocolate?") to get the convo off on an interesting (and confused) footing. You could also allow for the option to take control of one of the parties in case someone else has done the hard work of finding an interesting person for you.

I also cobbled together a version of the script which allows 3-way chatting (using alpha, beta, and gamma for the stranger aliases), but for some reason most people encountering it assumed that they were being trolled by a single stranger pretending to be two people at once. Can't think why. Anyway, like in physics where the probability of three particles being at the same place at the same time is much lower than two, arranging for three intelligent omegle users in the same chat requires beating astronomically bad odds.

Anyway, here's the script...

use strict;
use vars qw($ombot1 $ombot2);
use Thread;
use WWW::Omegle;
$ombot1 = WWW::Omegle->new(
                           on_connect    => \&connect_cb1,
                           on_chat       => \&chat_cb1,
                           on_disconnect => \&disconnect_cb1,
                           );
$ombot2 = WWW::Omegle->new(
                           on_connect    => \&connect_cb2,
                           on_chat       => \&chat_cb2,
                           on_disconnect => \&disconnect_cb2,
                           );
$ombot1->start;
$ombot2->start;

my $thr = new Thread \&sub1;

$ombot1->run_event_loop;
exit;

sub sub1 {
  $ombot2->run_event_loop;
}

sub connect_cb1 {
  print "Connected 1\n";
  sleep 2;
}

sub chat_cb1 {
  my ($omx, $what1) = @_;
  print "1> $what1\n";
  $ombot2->say($what1);
}

sub disconnect_cb1 {
  print "Disconnected 1.\n";
  $ombot2->disconnect;
}

sub connect_cb2 {
  print "Connected 2\n";
  sleep 2;
}

sub chat_cb2 {
  my ($omy, $what2) = @_;
  print "2> $what2\n";
  $ombot1->say($what2);
}

sub disconnect_cb2 {
  print "Disconnected 2.\n";
  $ombot1->disconnect;
}

Development Modes

In my experience, there are two primary modes of software development, which I'll term the heroic and the consensual.

In the heroic mode, the developer sets out on a quest (typically ill-defined, as for any good quest) with a goal in mind, and hacks and slashes a path through to the finale, slaying various dragons and other beasties on the way. Mysterious figures offer enigmatic words of advice from the sidelines, the full import of which our hero(ine) only realizes once an irreversible doom has been allowed to flower. ("You really don't want to disable that test; it's trying to tell you something...").

The hallmark of the heroic mode is unplanned impact. Indiana Jones leaves a trail of upturned vegetable carts and irate vendors in his wake, and we laugh, but in real life, it's QA, ops, techpubs, proserve, partners, and customers who pay the price. Perseus doesn't bother to ask Andromeda whether or not pulling out Medusa's head from the bag is a good way to solve the problem--he just does it, and it does solve the problem; it's a small detail that Andromeda ends up with most of her relatives turned to stone. ("Well, they weren't very nice people anyway...")

In contrast, the consensual mode proceeds by thinking, controlled experiments, prototyping, impact analysis, release planning, and migration discussions instead of immediate actions. This can be very good, or it can be very bad. The hallmark of the consensual mode is sitting in meetings, and that can lead to a very different kind of paralysis. However, when the parties involved are all experienced, know what they want to accomplish, and not playing games, it can work very well. A properly-timed discussion can avoid weeks of panic and firefighting in production.

When I was younger, the heroic mode came naturally for most coding projects, and an important part of gaining experience was to become conscious of unintended impact from changes I made. (I can still remember a very dirty look I received from a release manager one time when I checked in a random change smack in the middle of a CVS tag being applied for a release.) However, sometimes the heroic mode is what's called for in order to break a management deadlock--or at least to prove that it can be broken.

The tension between progressive and conservative forces is key to healthy evolution for just about any system, and software development is no exception. Open source naturally balances the two since it allows room for experiment while insisting that long-term architecture and quality be respected. Even for closed source development, a good approach is to apply the heroic mode in private (either before checking anything in, or in your own private branch or equivalent), but still conform to the consensual mode in all interactions with others. In other words, limit heroism to the sandbox, but use the results to drive discussion about how you're going to accomplish the real work. And oh, beware of the management gods, who will try to exploit or twist those results in ways you and others never intended.

OK, enough philosophy talk for the day.

Are We All Done Using FAIL As A Noun/Interjection Now?

Good, thanks, glad to hear it.

'Tis But a Scratch!

There have been quite a few questions in the twitterverse and elsewhere about the fate of LucidDB in the wake of LucidEra's shutdown.

Short answer: the project continues on under Eigenbase sponsorship and with a healthily growing user and developer community--we actually see this as an opportunity for members of that community to deepen their involvement. (Is there a spin doctor in the house?) LucidEra was selling neither support nor licenses for LucidDB (only using it as part of its on-demand service), so there's no change on that front.

For a longer answer, see the mailing list, which is where you can continue to get excellent free support.

Taking (Away) the Initiative

We now take an irregularly scheduled break from tech stuff for some political meandering.

On a number of occasions, I've been surprised during conversations with people who hold progressive views when they express antipathy towards the existence of the ballot initiative process itself (not just cases where it is glaringly abused). Maybe it is the closet demagogue in me, but direct democracy is quite appealing, and I would hate to see the baby thrown out with the bathwater. I'm also very happy about the existence of ballotpedia.org, since it provides the infrastructure for an open-source-style information collection and editing process, with adversarial dynamics generating something close to neutral POV in the aggregate. (Why not just use wikipedia? I think the idea is to have a ruleset and template more focused and stable than the generalized wikipedia free-for-all.) Here's an example article on our feathered and fattened friends.

This article has some interesting history of the initiative process in California as well as a critique of its current failings. Naturally, it was Progressives-with-a-capital-P who came up with it way back when.

Anyway, my sample of a handful of people so far is too small, so if you consider yourself progressive, do me a favor and use the comments section to answer the leading questionnaire below. I don't care where you live as long as (a) it is a representative democracy and (b) your state/region/whatever provides you a means for doing an end-run around your legislature/parliament/whatever.

• Do you think the general concept of a ballot initiative system is fundamentally flawed?
• If so, is it because you just don't like the results, dammit, e.g. you live in California and you're unhappy with Prop 8, 13, 209, 227, etc?
• Or is it due to distaste for mob rule? If this is the case, why are you OK with those same unwashed masses voting for officials in direct elections? (If you vote in the US, I'm assuming you don't have nice things to say about the electoral college system.) See, I didn't even use the word elitist, did I?
  
• Or is it because you think individual voters can't be expected to sort through all the information? In that case, wouldn't we be better off by figuring out how to load balance so that all citizens can participate efficiently, effectively, and collaboratively? (Let's start with a HOWTO guide with a decision tree for evaluating a set of propositions, including familiarization with resources such as ballotpedia, and then move on to crowdsourcing global views of the effects of each proposition on the budget. Or, like, make a video game out of it.)
  
• If none of my strawmen above...please explain.