beatnikblog

Here are some authors who have fundamentally influenced my life, and who might not effect yours if the Amazon Kindle were the only access you had to their works:

1. Italo Calvino (only _Hermit in Paris_)
2. Albert Camus (zero)
3. Richard Dawkins (only _The God Delusion_)
4. Umberto Eco (zero)
5. William Faulkner (zero)
6. Allen Ginsberg (zero)
7. Joseph Heller (only _Catch as Catch Can_)
8. Vladimir Nabokov (zero)
9. George Orwell (only _1984_)
10. Thomas Pynchon (zero)

There are many, many others of equal stature with woeful representation. Amazon, I’m sorry to say it baby, but there’s more to life than the NYT best sellers list and a stockpile of SciFi!

UPDATE: Also garnering honorable mention in the zero-representation club: John Steinbeck, whose portrait is used as a Kindle screensaver, no less.

Like David, I’ll also be talking about something other than what’s been listed on the LugRadio LIVE schedule.

I plan to show off a new feature of Workstation 6.5 Beta called VM Streaming. Basically, you click on a link like http://www.beatniksoftware.com/vmware/BeOS/beos.html and a locally running VM starts up, downloading on demand in real-time over HTTP. No muss, no fuss, no decompressing a zip file or insane download times.

See you at 2:30.

If there is large crowd demand, I can also show off Gimmie running as an AWN applet, or Pyro speeding along on the latest Firefox 3.0 beta… but I’ve only got 30 minutes!

View Larger Map

For as long as I can remember, I’ve held this quote from Eleanor Roosevelt as one of the most important concepts in my life:

Great minds discuss ideas. Average minds discuss events. Small minds discuss people.

Similarly, there are many minds thinking about the past, some thinking of the present, and only a few minds thinking about the future.

Some of these few are thinking up ideas about the future. And how to make our future into what it could become.

If you tend to find yourself at this particular cross section, then I’ll probably see you at Yuri’s Night Bay Area ‘08, happening Saturday at NASA Ames.

A word for how excited I am hasn’t been invented yet.

BUT it’ll be a long time coming if we keep the customers we have as happy as they seem to be, while adding to their number at a consistent rate.

Check out this Microsoft employee’s comparison of their still-unshipped virtualization server to VMware’s embedded virtualization server to see what I mean. Comments such as those left by our customers do not come easily.

Some choice quotes:

This post is FUD. How can I do vmotion, HA, DRS, vmotion with storage on [Windows Server Virtualization]?

Viridian is a year away, and you diss 3i features what are weeks away.

Vmotion has changed the way we do servers, and with DRS and HA, we now virtualize close to 80% of our new server deployments.

[MS’s] failure to recognize the extent and value of the virtualization market is Microsoft’s Second Great Mistake. (For the First Great Mistake, Google “global impact of the Internet”).

You are actually calling out VMware on new features they are releasing now and ** saying they’re not new because Windows WILL have them sometime next year **.

This post is just plain rude and stupid. It lacks any potential bounds to reality at all. If I was employeer (in this case MS) I would close this blog instantly since it doesn’t look good in the eyes of future customers.

Yes, even FreeTards like me can sometimes feel pride in their gigantic international proprietary corporate sugar daddy. But that also does not come easily.

Today I was sneaking around behind the scenes at the Tate Modern London. I saw the following etched on a wall for the employees beginning their day.

How To Work Better

1. Do one thing at a time
2. Know the problem
3. Learn to listen
4. Learn to ask questions
5. Distinguish sense from nonsense
6. Accept change as inevitable
7. Admit mistakes
8. Say it simple
9. Be calm
10. Smile

It was spray painted on, which I guess is the modern art equivalent of a granite engraving.

If this is true, it’s pretty amazing.

That long-running joke about the Semantic Web just got a lot funnier, because it might actually happen. Wow, imagine the Web as a huge indexed taxonomy, and an API to query it intelligently. Certainly enough for me to switch search engines, if you can believe it.

The idea of giving the default anonymous username/password of your Version Control System the permisson to commit anything. Anyone the ability to write as well as read. To test a very amazing response from excited engineers, testers and reviewers, and data researchers. And spammers too! In a well-coordinated test of the system to integrity issues, in the most open of ways.

…

Every two months we shall have a Free Commit Day! No username prior experience or otherwise permission required.

Coordinated with Google and Yahoo and Internet Archive to be aware when indexing open source repositories that are involved in the test of a Free and Open Commit Day for a specific one-day only affair.

…

A day when anyone can commit anything to any source repository. Every, say, 2 months repeating regularly… At the end of the day, the changes are reverted and sent to the maintainers of individual modules. Opt-in not out. A right to share via code your ideas, for all to see.

…

The reason I am still interested in Distributed Source Configuration Management. So maybe this could be the normal mode of operations. Every day.

Jacob Appelbaum, my close friend and former roommate, along with a team of crack security specialists has published an amazing piece of research (see also the NYT article). It shows that a physical vulnerability in computer memory chips means that RAM content can be captured at any time.

Operating systems and programs have a lot of important stuff floating around in memory. Things like encryption keys to private data and protected files. Even intermediate encryption state that’s kept in memory can drastically simplify brute-force decryption attacks.

This means that stealing a laptop that is suspended or running can be exploited to gain access to encrypted files and protected networks, for instance. In fact, just having a moment of physical access to insert a thumb drive and press the power button is enough.

As a free software and data advocate, this is most frightening because it allows hardware and software vendors to leverage the fear and high risk involved to make a short-sighted push towards stronger DRM.

Funny, but I suddenly feel better about years of poor laptop suspend support in Linux!

Really interested to see what happens here.

In September 2004 all my friends were hacking on Mono. Miguel did it out of a belief that he was helping to fight a future Microsoft monopoly, others out of exhaustion with C. At the time it took around 150 lines of boilerplate code to make a new class.

Projects like Dashboard, Beagle, F-spot, and the Mono runtime itself were all about pulling great hacks in unknown areas using strong tooling. And about creating value for Ximian and Gnome.

I had just returned from 6 months of bumming around in Brazil. I had no money. I was staying with my Dad in Florida, and playing Capoeira every day.

I wanted to show the world that Mono could make usable applications. No one outside the Mono/Ximian community knew at the time whether this was a fast enough VM or whether the Gtk# bindings were mature. Tomboy was really the first usable app for Mono/Gtk, mostly because it was absurdly simple UI.

GNOME screenshot on Wikipedia, featuring Tomboy

I also had a political agenda. I wanted the question of Mono or Not to be brought forward and answered seriously, instead of foundering in the grey waters of FUD. I didn’t honestly care about the outcome, just that there was one. I thought a killer Mono-based app would push the issue.

At 24 I hadn’t yet reached my wizened state as a Total Language Agnostic (TLA). I was sick of C, I knew that. I thought having first-class signals would make event-based UI programming easier, which it did. Java hadn’t yet been open sourced, and hadn’t yet been pressured into matching the C# featureset, which they did in Java 1.5. Today I wouldn’t waste my time on language politics.

But mostly I wrote Tomboy because I have a horrible memory. I thought dumping thoughts in a loosely structured setting could help. At the time my home directory was filled with dozens of files named like “WHERE-JACOB-SAYS-I-LIVE”, which contained the first address I ever had in Boston.

I only wish I had written down why I called it Tomboy.

Luckily the name stuck, instead of Buttboy, which is what Miguel started calling it immediately after I told him about the project.

*UPDATE: This confusing title comes from an amazingly well-handled flamefest on GNOME’s desktop-devel-list today. It was really heartwarming to read what you all had to say!

Everything small shall be bourne out.
In time, all else shall become smaller.

Overall, I’m a pretty terrible free software maintainer.

I don’t communicate well, and don’t plan or organize nearly enough. I disappear and get distracted. I get frustrated a lot, and don’t work on the nitty-gritty stuff. I make arbitrary design decisions that turn out flat wrong.

And I certainly don’t know what to do when things go awry, like they are with the Gimmie project and its upcoming 0.3 release.

I’m looking at a big mess of intractable changes, but important nonetheless: months of development work and iteration done by a couple awesome contributors still new to free software development (they learned Python just to contribute!).

Caused by a lack of oversight on my part and mixed with confusion over expectations on both sides, we’ve ended up with a divergent Gimmie codebase: the gimmie-dev branch.

Patches haven’t been created against the trunk code as I had hoped for, and now neither I nor the contributors know where to begin to merge the two.

Files have been moved around, chopped up and reassembled, all without VCS tracking. New design decisions made and code not explained. Portions rewritten on bad assumptions. Changes to both UI and framework that I don’t understand or necessarily agree with.

Somewhere in there is a plugin framework and a content categorization system I’d love to keep, and certainly many genuine bug fixes and good design changes.

But how to approach it? I titter between attempting to make discrete patches I can review and merge, trying to motivate the contributors to do it, and wanting to give up and rewrite it all from scratch.

Most importantly, I’m scared I’ll lose great contributors by making them feel unappreciated, or slowing them down with too much dirty work. Without new blood and motivation no free software project can live.

I’m sure other maintainers have been in a similar place. Can anyone offer advice on how to progress? What has worked for you in the past to get over difficult technical and social hurdles? How do you work to grow disciplined contributorship but still keep people happy?

I’ve just committed basic support for concurrent AJAX requests in Er.js. From the Er.js homepage:

Concurrent AJAX with Er.Ajax

XmlHttpRequest, AJAX and JSON integrate nicely with the process and message-passing model, allowing processes to avoid asynchronous JavaScript and callbacks.

Instead, using message-passing and concurrency, Er.js makes network access transparent, without blocking other processes or interactivity:

result = yield Er.Ajax.get(”http://beatniksf.com/erjs/index.html”);
alert(”Fetched Content: ” + result.Text);

Under the covers, this is accomplished using a concurrently spawned process (started via Er.Ajax.spawn), which handles XmlHttpRequest internals. The spawned process uses Er.send to tell our process about download progress and completion.

Er.Ajax.get and others (post, json, etc) are implemented by yielding execution until the final message from the spawned process is received, and then returning it to the caller:

function myGet(url) {
   var pid = Er.Ajax.spawn(Er.pid(), url);
   yield Er.receive({ From: pid, Success: _, _:_ },
                    function(msg) { return msg; });
}

Pretty cool stuff, and not bad for a Christmas day hack.

If you’re running on Firefox (the only browser with JavaScript 1.7 support currently), see this in action on the test page.

Hopefully soon I’ll have a bit of time (or help!) to round out the library: Erlang-style RPCs over JSON, concurrent DOM Eventing, and real native threading using Google Gears.

UPDATE: My hosting provider has been very flaky due to a lot of inbound trafic from reddit.com. Please use the mirror in the mean time, until things stabilize a bit. Everything has recovered now. You can also check out the new Er.js homepage.

I’ve just posted up a fun hack that I’ve been playing with the last few days… it’s called Erjs; short for Erlang-in-JavaScript.

Erjs piggybacks on Neil Mix’s Thread.js which fakes threading in JavaScript 1.7 using coroutines and nested generator continuations. My idea was to replicate Erlang’s concurrent lockless process model and message-passing in JavaScript.

Running a JavaScript function in the background is easy with Erjs:

Er.spawn(myBackgroundFunction);

Er.spawn starts a new Erjs process running myBackgroundFunction, and returns its process id.

Because processes are really coroutines, you have to call yield before any function which might block. Calling yield will create a continuation trampoline that can be rerun by Erjs when it’s time for the process to continue executing. For example:

function myBackgroundFunction() {
   // Wait for 4 seconds
   yield Er.sleep(4000);
   // Do other things…
}

In Erlang and Erjs, each process has a built-in message queue that other processes use to send it messages. Posting to the message queue never blocks the caller, and the destination process for the message can read them off the queue whenever it wants. Messages are just regular associative arrays, similar to hashtables, which are easy to create in JavaScript. For example:

Er.send(myPid, { Hello: new Date(), From: Er.pid() });

Here, myPid is assumed to be the process id from some former call to Er.spawn. This call sends a message with the keys “Hello” and “From”. Hello is a Date object with the current date, and From is the process id of the current process, which can always be fetched with Er.pid(). Passing the current pid means the myPid process can send us messages in return, since we’ve told it who we are.

When myBackgroundFunction wants to read off its message queue, it calls the Er.receive function, telling it the kind of message it’s interested in, and a function to call when such a message is received. Interest in a message is expressed using a message pattern which, just like the messages themselves, is a simple hash table.

yield Er.receive({ Hello: Date, From: _ },     // pattern
                 function(msg) {               // handler
                    log(”Hello=” + msg.Hello);
                    log(”From=” + msg.From);
                 });

This matches any message in the current process’s queue which has a Hello key with a Date object as the value, and with a From key with any value. Explicit value matching for number and string literals and object references is also possible. The “_” for the From key means that any value is accepted. There are a few other matching rules as well that make this a very powerful but simple message dispatching mechanism.

If a message matches the pattern, it is passed to the handler function specified in the following argument to Er.receive. The handler can look up the key values it needs in order to act on the message. It can also send messages to other processes, spawn new processes, receive queued messages or perform other work.

Because the Er.receive call doesn’t return until a message matching one of patterns is received and handled, we put a yield in front of the call to avoid blocking.

When a process finishes or exits, it automatically sends a message to any processes which link to it. Linking is done by passing a pid to Er.link. The sent message is of the form:

{ Signal: Er.Exit, From: exiting_pid, Reason: reason }

The Reason value comes either from the exiting process calling Er.exit(reason), or just throwing the reason as an exception. If the linking process does not handle this message, it will exit itself, sending exit messages to its own linked processes. This allows for simple process chaining and failure handling.

Processes can also register to receive messages sent to a given name string, using Er.register(name). Registered names can be passed as the first argument to Er.send. Multiple processes can register for the same name, and they will all receive a message sent to that name, allowing for simple multi-casting.

To see Erjs in action, check out the example page, and view source. Er.js itself can be found here.

Still reeling from the awesome Android announcement today. If you haven’t tried it yet, download the SDK and play with the cell phone emulator. Fire up Eclipse and create a new cell phone app. Rest assured; it all works on Linux/Win/OSX.

What I’m reeling from is just how much of a game-changer, or rather game-ender, this platform is. For instance, all of these platforms will from now on constantly be plagued with the question of “Why not use Android?”

• JavaFX
• FlashLite
• QNX (okay, I was admittedly a little over eager regarding this one.)
• WindowsMobile
• Symbian
• BlackBerry
• Qtopia
• OpenMoko
• Sugar
• Maemo
• iPhone

All of these are either restrictively closed platforms, use unfriendly low-level languages, don’t scale to support 3D or iPhone-quality animations, don’t have useful widget reuse, don’t allow replacing core components, etc etc.

I assume that Google will soon provide some easy AdWord embedding API to further stimulate application development.

Or perhaps they’ll keep it classy by tying applications implicitly to Ad revenues. So for instance when your Android app embeds the built in Map component, and a user happens to use that map (and GPS) to find a nearby sausage stand, a cut of the sausage stand’s Ad payments goes to the application’s author.

This is the true underlying beauty of Android, and the reason it can be completely free, open, and heavily developer-focused: No one can monetize a mobile platform’s application developers like Google and their AdEmpire can.

(Or possibly Facebook, given another year or so.)

I predict Android will massively change the face of every day technologies for years to come.

UPDATE: See Stefano’s excellent analysis of how big this announcement really is.

ATTENTION ALL METROPOLITAN BOSTON AREA LISTENERS: Anyone kind enough and so endowed so as to provide me with a classy bowtie and cufflinks on short notice — as in tomorrow for Joey’s wedding — please contact me at alex@beatniksoftware.com.

UPDATE: Turns out the ceremony was at night, so I had ample time to hit up Lord&Taylor for some overpriced accoutrement.

A couple weeks about I sent a mail to the zero-traffic Hack2Hack Google Group admin…

From: Alex Graveley
To: hack2hack-owner@googlegroups.com

Hi,

I want to start a programming advice discussion group, for mostly free software hackers, but open anyone really. I really like the name “hack2hack”, and I notice that you’re not really using this list for anything. Would you perhaps consider making me a group maintainer so I can start subscribing people and getting the discussion flowing?

If you want to check out some of my hacks, see http://beatniksoftware.com.

Thanks!
-Alex

A few days ago, I received a response…

From: haider ali hza
To: Alex Graveley

Hi Alex
I allow you to subscribe people in my group “hack2hack”, but only in one condition. firstly you will have to give me pay for this only 250$ US Dollar.

WTF??!

I wake up this morning and read some of the bloggy rants about Miguel’s latest endeavor. Which, btw, helps MS crush it’s competitors using open source as leverage.

Simon Phipps from Sun is complaining that the terms of Silverlight on non-Linux is — *gasp* — a completely standard proprietary EULA!

Which of course Sun would never consider since they’re a totally open and friendly company forever and ever having open-sourced Java like what, 2 months ago? And only after more than enough pressure from .NET.

Poking at the Sun dude’s blog, I notice something about Aptana. The wicked-sweet Web2.0 IDE built on Eclipse. (See UPDATE below.)

Simon notes that Aptana changed their license… they revoked redistribution! All redistribution.

Welcome to Open-but-you’re-screwed City. Renamed recently from Ambiguously Shady Softwareville, after a massive population influx.

What’s worse, Aptana has a forum thread where some innocent asks “Err, does this mean it’s not free software anymore?” and a marketteer responds with a nice smoke/mirror routine about the source being totally free (as in cost, not freedom). Nothing about the newly minted lack of redist rights.

In case you forgot, redistribution is the definition of Free Software. This is why Stallman coined it and campaigned for it and put his money where his mouth is (i.e. Emacs).

So I mention this to the Mozilla developers. Because I figure they’d like to know. It turns out they would like to know, because they actually care about software freedom! Yay Mozilla hackers, much love. (Paragraph highly edited, see UPDATE below.)

Somewhere along that discussion someone mentions the newest Steve Yegge blog post that’s sort of related to open sourceiness.

I hate to love Steve. He’s just another Google Kool-Aid wank. But a ballsy one with common sense. Also, his style has me writing in this phrenetic geek milieu, so the man can influence, certainly.

Anyway Yegge vid-links to his OSCON talk. That’s O’Reilly’s big Open Source Convention.

Audio on my laptop doesn’t work because I run Linux, and I’m lazy, so l just watch him flap his gums silently for a few minutes, transfixed. Then I’m bored and I start poking around at the other recorded talks.

After a few clicks I realize: “Hey! ALMOST NONE OF THESE PEOPLE WRITE OR HAVE WRITTEN FREE OR OPEN SOFTWARE.” Superman’s alter ego, Simon Peyton-Jones excluded. And ladyada, mosdef.

Great technologists all, but at The Open Source Convention? True, most have released existing codebases once the act of open sourcing became competitively valuable.

But isn’t there something of a bigger point to free software? How many years ago did it become a pundits-only affair? Was it ever not? Perplex.

Pundit means someone who talks a lot but doesn’t do much, in case you forgot.

Of course, I’m just sad that I didn’t get invited back to FooCamp this year, and that I didn’t get asked to go to or speak at OSCON.

So to review, I wake this beautiful San Francisco morning to find that open source today means:

1. License finger pointing from corporate-initiative-backed genetically-engineered high horses.
2. Proprietary manipulation (MS) of open source developers’ mindshare and quiescence.
3. Funded tacit acceptance of said manipulation (Novell).
4. Ballyhooed community conferences where the hacker:noise ratio is some cruel joke.
5. I am not as popular as I want to be.

Luckily, VMWare is now a big-name publicly traded company. One with a vested and developer-driven interest in helping to improve open source while simultaneously assuring our share holders’ interests and continued crushing of our competition.

And we don’t employ any pundits to convince you otherwise. Or that the previous paragraph is written by some weirdo crank who is just trying to poo-poo all our obviously pure goodwill flower-smelling since-the-beginning-of-time open source contributions.

Funnily, thanks to the IPO, I bet some of us will get invited to all the cool-kid conferences next year to talk about VMware’s implications on open source.

But not to talk about the free software a bunch of us write every night out of interest in technology, a desire to tinker, and yes, love.

Is that because our tinkerings have an implicit lack of revenue/book sale generation power for some open-source-friendly-while-it-makes-competitive-sense corporate entity? How unfortunate.

Oh, btw. Last week I forked some dude’s awesome GPL codebase for my own nefarious code-editor improvement purposes. MUAHAHAHA.

Get it here, if you have the guts to actually compile software anymore. More on this later if it turns into something good.

UPDATE: ActiveState has nothing to do with Aptana. ActiveState’s awesome hackers work on the OpenKomodo IDE, which is MPL/GPL/LGPL. There is also no connection with Mozilla and Aptana. This is a pretty lame bobble on my part. Forgive me.

Thought-provoking post from Stefano (as usual) as to the merits of decentralized source control systems like Git. The most interesting bits to me are the possible community health risks of not using such a system.

When we started Pyro, my first task was to set up the version control system. I spent around 30 minutes searching and fiddling, trying to figure out how to store a simple Git repository on my hosted web server. Something that I would consider to be the main usecase for such a system.

Eventually I gave up, opting for Bzr, which was a joy to set up. My first commit message succinctly expressed the annoyance I was feeling at the time: “Fuck Git.”

But in the end, we made the pragmatic decision to switch to Subversion. Why? Because people kept complaining that they didn’t have Bzr installed, and were too lazy to figure it out just so they could try out our random project.

Unfortunately, this kind of laziness has become pervasive in the Free Software world, as compared to say 10 years ago. Back then it was all but expected that you’d have to fix the build to get something working. But it was fine, because you would fix it and send a quick patch. Believe it or not, this actually felt pretty awesome. You were helping to keep the train on the tracks, and that meant getting your hands messy.

Today I worry that people are unwilling to try out new things. At least until their Linux distribution makes installing them a single command-line away. Getting people to build from source is now akin to pulling teeth.

Even more worrisome, there seems to be a strong correlation between developer seniority and the unwillingness to tinker with new things. Ideally, getting the people who have the most to offer interested in a fledgling project would be easier, and senior people would be seeking out new projects to toy with, eager to get involved (even in just an advisory role).

I’m wondering if a decentralized source system could help make this better, and bring us back to the bad old days. Maybe breaking from the “Give me a packaged Deb/RPM release, then we’ll talk” mentality and back to scary, unreliable bleeding-edge source code would be a good thing.

In case you haven’t heard, VMware Inc. (NYSE:VMW) IPO’d today.

There has been a lot of pent up excitement leading up to this.

“Shit. That was today?! Why didn’t anyone wake me!”

And tension has been running high lately.

Obviously, no one wants to be left out.

Chippy missed the pre-party

And no one wants to end up all wet.

And some have even resorted to superstition.

When aluminum hats just aren’t enough.

But now that’s it’s over, I’m glad to see that it’s back to business as usual.

New company logo?

A post from Quim this morning got me thinking about corporate Open Source awareness, both by the corporations themselves and the community at large.

It gave me the idea of a Web site that would track companies and organizations that are Open Source-friendly.

If done correctly this could help companies get more from their opened sources, and help the Open Source community get more out of these projects. I have a feeling this could be a killer resource for everyone.

Imagine a common, independent, non-profit place that would…

1. List resources for finding and joining projects run by large companies.

   Companies tend to avoid more de facto project management sites like freshmeat or sourceforge, instead listing projects on web pages they control. They also use various means for bug tracking, and discussion lists, and patch review.

   This is usually determined by years of corporate-culture precedent, and can be very difficult to grok for outsides. Such a site could link to project resources like source code repos, bug trackers, discussion lists, and project licensing info.

2. Explain how to interact with the existing developer community for a project.

   Knowing who’s in charge of a project, whether they like patches sent to the mailing list or Bugzilla, coding style, etc. etc. could aid contribution immensely. It could also help to make developers inside companies who don’t come from an Open Source background feel more comfortable with outside contributions.

3. Streamline requirements from external contributions.

   Some company-driven open projects require registration or copyright assignment before they’ll accept patches. Or maybe you have to register for a developer account before accessing source code.

   Finding and submitting this stuff is always a major turn-off for new contributors. It’d be awesome to streamline the process by linking to signup forms and even allowing online registration.

   Collecting this info would be good for companies choosing to take the plunge into Open Source project maintenance. It could let them see how others have approached the problems of ownership and legality, and choose a scheme that works for them without fear of alienating developers.

4. Track news and announcements about new open projects and developments originating from corporate entities.

   Only the largest and most open-savvy companies know how to market their opened works to the community, which is a shame.

   Everyone benefits from valuable open source projects, so there should be a good way to learn about new stuff from trusted and financed sources.

5. Create a competitive ranking of companies that play nice with Open Source (aka Karma Score).

   Companies should feel good about their open contributions, and get some respect for doing a good job.

   Quantifying this would be a pretty interesting problem to solve — involving company stats, project stats, community involvement, patch acceptance, upstream efforts, etc etc.

   Maybe let people +1 companies or projects who do a good job, and -1 when they screw up. Let contributors write up reviews and FAQs based on their experience integrating into these projects.

   This would create a direct feedback loop that could be understandable to management. A sort of karma tracking. It would also help open source developers seeking employment to identify companies with a good track record for using and contributing to open source.

   Appealing to new employees could make an Open Source Karma Score really valuable.

   Finding good people is a huge challenge, and Open Source has already established itself as a camp of smarties looking for action… but with a strong bias toward those companies that know how to share in the Open Source mentality.

Anyway, back to my real work…