Tuesday was the second and final day of the tutorial sessions. In the morning I attended a tutorial on PostgreSQL’s new hot stand-by and streaming replication features; and, in the afternoon I attended part of a tutorial on Cassandra. Why only part? I’ll get to that.

I didn’t feel like going across the river to the food trucks for lunch, so I joined Debbie for lunch at Burgerville. Aside from the delicious food made from local ingredients, there are two things that struck me about Burgerville. The first I noticed when I walked in the door: for the first time, disposing of my trash would require me to read instructions. Burgerville uses three bins for trash: one for recyclable materials, one for compost, and finally one for trash that can neither be recycled nor composted. I thought this was neat, though I did get a kick out of the soft drink cup. It’s from the Coca-Cola company and advertises itself as something that can be composted; with the footnote that this was only possible in a large facility capable of composting such cups. Not something one can throw into their garden compost pile, I guess. The second thing I noticed caused me immediate regret: the receipt lists the calorie count of the foods ordered, along with carbohydrate and fiber content. Looking over the details of the burger, onion rings, and raspberry milkshake I ordered, I decided that it would not be a very paleo day for me. Oh well, the milkshake was very good.

While enjoying our carb-loaded, calorie-filled lunch, Debbie noticed someone wearing a pair of Vibram FiveFingers that we hadn’t seen before. From a distance, they looked almost like normal shoes and appeared to be made with a dark brown suede. With both of us deciding that a post-lunch, calorie-burning walk was called for, and sharing a desire to buy a new pair of FiveFingers, we set out for Portland’s REI store. A trip on the MAX, a walk, a few blocks on the trolley, and another walk brought us to the store.

The shoes turned out to be the KSO Trek. They’re very nice and I’m considering purchasing a pair for hiking. Unfortunately, I struck out on the trip. REI has been having a hard time keeping FiveFingers in stock, so I wasn’t able to find or buy a pair of the Classic version. Fortunately, I’m still satisfied with my KSOs, which I was wearing at the time.

Our impromptu quest for footwear took us well beyond the alloted time for lunch. Fortunately, this time was not wasted. While walking, we had received a call from our coworker back in the expo hall, who needed help setting up the QuIC booth. For some reason, it was fun being allowed into the expo hall while booths were still being constructed. Not sure why, other than that I enjoy seeing things taken apart and (sometimes) being put back together. After getting the booth set up, I made it to the second half of the Cassandra tutorial. I’m told by those who attended the first half that I didn’t miss much.

We had some time to kill between the end of the day’s sessions and the evening’s Ignite talks. So we walked a few blocks to a place called rontoms. Had I not been looking for the specific address, I would have walked right past, not noticing that this was either a restaurant or a bar. The cavernous interior was devoid of anyone save the bartender and a waitress, who would disappear as quickly as she appeared. The photographs on the wall, ost of which featured a man in an animal costume, ranged from strange to disturbing. After a moment’s hesitation, we ventured out back to find a patio crowded with patrons enjoying food, beer, and spirits. With what appeared to be only a single waitress working and not having particularly strong appetites, we went back inside, obtained pints directly from the bartender, and found a comfortable area to sit and chat. Twice we encountered people entering the restaurant, looking for people they didn’t know by sight. Both times my colleagues convinced them that we were those people; one girl even sat down with us for a few minutes before we let her in on the joke. After a while, I received a page from Jonathan that there was beer, salami, and cheese being served outside the ballroom at the convention center. This sounded like an excellent and delicious dinner to me, so I made my way back.

I hadn’t been to an Ignite session before, so I was looking forward to this one. Right off the bat we were warned that we would likely enjoy some talks and dislike others. Fortunately, each talk would only last five minutes, so we were free to use the time to retrieve another beer. By the time we returned, the talk would be over. I don’t believe I took advantage of this, instead waiting for the break, during which some awards were being presented.

Two talks stand out in my memory. The first, perhaps appropriately, was the first in the lineup: Paul Fenwick talking about Maximum XP: Optimising life for adventure (which he gave again, at a much better pace, at the Perl Lightning Talks). Presented in song, Paul’s message seemed to be to enjoy travel and to take advantage of opportunities to meet people and have fun. Based on what I’ve read on his Twitter stream, I’d say he’s been successful.

The other talk, Your Infinite Do-Loop Exercises Bores Me, struck a chord with me. John Scott and Jim Stogdill paired up for this talk, one would perform exercises while the other would speak, switching places at the halfway mark. Not only was it refreshing to see a talk about fitness at a convention populated by a class of people not known for their physical exertion, but it was about a method of fitness I’ve recently become interested in. While I don’t practice CrossFit myself, I frequently look at the exercises on the site and prefer it to the typical, repetitive gym workout. They also mentioned the paleo diet, which, along with the primal lifestyle, I’ve become a big fan of.

My coworkers all turned in early, so I hopped back on the MAX and headed downtown to have drinks with Kevin at Bailey’s Tap Room. I had a wonderful sour beer, which I no longer remember the name or origin of, and had the pleasure of meeting Steve, Jeff, and Michael Schwern. Jeff and Schwern were discussing the use of the Log4perl module in the latter’s gitpan project.

After last call at Bailey’s, I caught the last yellow line across the river and turned in myself.

This session is a companion to the session on competition r0ml presented on Wednesday. For those of us who, for whatever reason, were unable to attend the previous session, he provided us with five second summaries:

• Wednesday: Competition is bad, don’t do it.
• Thursday: Licensing is bad, don’t do it.

And with that, the session is over.

I’m kidding, of course. The best part of any of r0ml’s talks is the logic he uses to get from his observation to his conclusion. As he noted at the outset, the path typically takes us through the Middle Ages.

I don’t deal with lawyers very much in my day job, since I work in a support role for our engineering departments. However, I know several people in our Open Source group, and have attempted to release some of the Perl modules I’ve written while on the job. Doing so is decidedly non-trivial and, after two years I still haven’t been allowed to release my code. To say I’m disappointed is an understatement.

My experience with lawyers has been that they are extremely cautious. While frustrating, I understand that it’s their job to play it safe and to protect the company. They are scared, almost beyond reason, that an Open Source license will find its way into a piece of intellectual property that they’d rather not release. It can’t be easy trying to bridge the gap between the closed and open ways of doing business.

The topic was introduced with a question: What is the difference between copyright and plagiarism? Plagiarism is forever. I didn’t quite catch what r0ml meant by this, but I suspect it means that copyright (eventually) expires, granting the work in question to the public domain. Plagiarism, if one can get away with it, creates an attribution that lasts forever.

That, if one is an Open Source geek, leads one to think about licenses. Let’s take the attribution clause of the BSD, which contains two sub-clauses, for example. It’s redundant. It effectively means that the recipient of the source code can not claim credit for the author’s work. Under copyright law, this is already the case, so why the redundancy.

In the name of efficiency and refactoring, r0ml mused whether it would be possible to reduce the number of license clauses to one. He found this in the Do What The Fuck You Want To Public License.

Through inductive reasoning, if we can reduce the number of clauses from two to one, we should be able to similarly reduce the number of clauses from one to zero. After all, if we begin with the earlier premise that licenses are bad, this should be the goal, right?

First, briefly, why are licenses bad? There are many reasons and many arguments; too many of each for this post, but to summarize a few important ones, as of this writing, the Open Source Initiative lists 73 approved licenses. Choosing between them can be a daunting task. Neither do all of these licenses play well with each other, further complicating the selection task if one is attempting to integrate differently-licensed source code. Finally, it’s rare that anyone knows all that they are agreeing to in the license.

The Medieval sensibility was that all knowledge came either from God or from the Ancients. As such, no one could claim credit for a work, because, without exception, it would be plagiarism. For this reason, the majority of works produced during the Middle Ages were compilations, a representation of existing information.

We have a modern equivalent of this Medieval concept of copyright, called the Compilation Copyright. A compilation of files in the public domain is assembled with copyright only on the compilation. Further, no one may claim credit on the same collection of files. Instead, a new compilation, or derivative work, must be created.

How bad has copyright gotten? Well, thanks to the Apple development kit, there is a short piece of code, included in every project, that is separately copyrighted by everyone who has used the development kit. This is getting out of hand, to say the least.

So r0ml wrote unlicense.rb, which will scan a directory recursively, removing any licenses it finds. This, of course, is perfectly acceptable under the terms of the licenses being removed, so long as the files aren’t redistributed. It does have the effect of pleasing the obsessive-compulsive user.

Under the laws of many countries, a copyright notice isn’t actually required to have a copyright. This is particularly true in the United States and the European Union. In fact, in the latter one cannot even waive the protections of copyright. This creates the default case: without a license, nobody other than the author has the right to do anything with the code. The default is all rights reserved.

Richard Stallman, founder of the GNU project and the Free Software Foundation, was not trying to protect the author of code from people downloading the code; rather, he created the GNU General Public License to protect the users of the code. He felt that users have an inherent right to have access to the code running on their computer. Thus, the primary reason for the creation of Open Source licenses was to protect the user.

Many companies claim that they have an Open Source business model. Typically what this means is that they offer their software, or some subset of their software for free, under an Open Source license. Then they offer support contracts, for usually high prices. These aren’t really Open Source business models. The SQLite project has the only known true Open Source business model. The software itself is released into the public domain. This is a scary place for lawyers, especially those employed by large companies. To assuage their concerns, the company that employs the author of SQLite will be more than happy to sell them an Open Source license for the code.

Next, r0ml talked about warranties. In some jurisdictions, the default case under the law is that there is an implied warranty, unless stated otherwise. Most of us have seen the disclaimer of warranty, included to protect the author, attached to the license in code we have downloaded (or added it to code we’ve released), usually in all capital letters. While not a strict requirement to be in capital letters, it is a requirement that the disclaimer be made to stand out. Often, licenses are in plain text files, so using a bold face type isn’t possible. Hence, capital letters. The simplest case of a disclaimer is such:

/* This program comes without any warranty, to the extent permitted by law. */

As we recall, the default case under the law is an implied warranty so including the phrase “to the extent permitted by law” is redundant. Also, it should be noted that copyright law, in the United States, is codified at the Federal level, in Title 17 of the United States Code, while warranty law is codified by the states. This leads to many more jurisdictions, and far more potential confusion, for warranty law.

So finally, here is r0ml’s part serious, part humorous take away: don’t include either a copyright or a warranty with your code. If a user sues you for damages under the implied warranty in a state court, counter-sue them in US federal court for copyright infringement. After all, under the law they were not given permission to copy the code anyway.

A question came at the end of the session, from someone who appeared mildly upset and defensive. He pointed out that Stallman created the GNU General Public License for a good reason, which wasn’t mentioned by r0ml during his talk. Someone had taken the code Stallman was freely distributing and sold it. After which, they went back to Stallman to inform him that he could no longer distribute his own code, because he hadn’t licensed it. The questioner appeared to be offended by the whole point of the session, apparently feeling that all the work Stallman has done for Free Software was being ridiculed and that, without these licenses, “capitalists” will simply steal the code for their own nefarious purposes.

To this, r0ml did have a response. Copyright law has changed since Stallman faced the problem that led to his creation of Free Software. It has become more strict and the requirement for registration has been dropped. The point was made that the questioner is actually referring to the concept of provenance, not copyright. However, this concept was not further explored as, unfortunately, time had run out.

Your Work in Open Source, 3 years of Incremental Change

Chris DiBona (Google, Inc.)

Google crawled 40 million files in Google Code to generate statistics on what’s in there. Lines of code and numbers of commits are not the most useful of metrics but that’s what they have to use.

The Gnu General Public License is the most used license, at over 50%. Of those, more than half have moved to GPL version 3. Perl has declined a bit, but C has the most use, at about 40%.

Many companies are committing code, too.

Mayor Sam Adams

Sam Adams (City of Portland, Oregon)

Last September, Portland adopted one of the first Open Source policies in the nation. They’ve committed themselves to open software, open data, and Open Source in the procurement process for software.

It’s pretty cool when a politician gets it.

Situation Normal, Everything Must Change

Simon Wardley (Leading Edge Forum (CSC))

Simon started with a recap of the talk he gave last year, which showed correlations between the ubiquity and certainty. All technologies follow the same curve, from having both low ubiquity and certainty up to having both high ubiquity and certainty. The stages tend to be the innovation of a technology, the productization, and finally the comoditization.

The basic idea was that the cloud, as it is known, is still in its infancy. As it matures, we will see innovations built on it at an accelerated rate. If we don’t pay attention to it, we’ll be left behind.

Well defined processes stifle innovation.

Projects or teams can be organized by lifecycle: innovation, leverage, and commoditize. This circles back on itself. When one thing is commoditized, a new innovation can be built on top of it.

Larry claims that so rarely does he talk about Perl in the States of the Onion addresses that he has brought his conscience with him today to prod him in the right direction (the aforementioned angel and devil).

The current state of the onion is segmented into left, central, and right sections. It can be labeled, say, 5 and 6. They can also be labeled 0 and 1, for false and true. Larry then asked a series of boolean questions, asking the audience to weigh in on the veracity.

Do you think Perl 5 and Perl 6 are really the same language?

Do you think Perl 5 and Perl 6 are really different languages?

As the angel and the devil argued, Larry pointed out that an important skill for a language designer is to be able to stay on the fence long enough until he can determine which side the grass is greener on. Sometimes you discover that you’re sitting on the wrong fence and the voices in your head start to argue about which side has the greener grass.

When the voices in your head start arguing if the purple cow eats greener grass than the brown fence, it’s time to see a doctor. Or find a better drug dealer.

— Larry Wall

This is, of course, a metaphor for being a language designer. Sometimes you sit on the fence for language features, without ever knowing which direction is the better one.

Next up is a live demo of Perl 6; or, more specifically, of Rakudo Star, which is scheduled to be released next week. Some of the demos, without comment:

.say if 6 %% $_ for 1..^6

[+] gather { take $_ if 6 %% $_ for 1..^6 }

[+] grep { 6 %% $_ }, 1..^6

~[+] grep 6 %% *, 1..^6

-> $n { $n == [+] grep $n %% *,  ..^ $n }

-> $n { $n == [+] grep $n %% *,  ..^ $n }(6)

At this point, the examples scrolled off the screen due to a “whatever” example being run. That’s good news, though. It means Rakudo Star supports lazy lists and, as such, we finally have those infinite lists we’ve been promised:

0, 1, ... *

The whatever star can, in addition to being used as in an infinite series, can be used to curry a function:

(1, 1, *+* ... *)[^20]    # Fibbonacci

(0, !* ... *)[^20]        # 0 1 0 1 0 1 ...

In a recent video interview, Larry was asked, if he were hit by a bus, has he designated anyone to be his successor as the leader of the Perl 6 project? His response was that he trusts the Perl community to choose the right person.

Onions can make you cry, so can disruptive technologies or innovations. Almost everyone has labeled their technology as disruptive. As such, the phrase has lost most of its meaning.

A disruptive technology simultaneously does something worse and does something better than its competitors. In a time of the Unix philosophy of “do one thing and do it well,” Perl came along and attempted to do everything, but didn’t necessarily do any of it well. The Unix philosophy was broken by its own utilities. No one knew what a “thing” was, and no utility of the time did it well. By the time Perl 4 turned into Perl 5, it demonstrated that a tool that was itself an entire tool shed could run circles around shell scripts.

In California, we once had many, many colonies of ants. Now, most of California is populated by a single colony of Argentine ants. This is because the colonies have forgotten how to fight with each other. Perl 6 has benefited from multiple teams creating multiple implementations, in the end working together to create a better product, even if that product takes longer to complete.

If you don’t like Camelia, you can just fork off.

— Larry Wall

The takeaway, I think: It is up to all of us to determine what Perl 6 will be. What kind of disruptive technology will it be?

Ever since I saw An Illustrated History of Failure two years ago, I’ve made it a point to see @pjf‘s talks. That’s how I find myself in his mid-afternoon session, Awesome Things You’ve Missed in Perl. Judging by the size of the crowd, I’m not the only one. However, I won’t attempt to pass along his humour in this post. I’d never do it justice.

In his introduction, Piers Cawley asked that we go wild when Paul took the stage, so the folks in the Google Wave session next door would be taken aback, and realize that Perl is not, in fact, dead.

People are still out there writing Perl as if still in the dark ages of 2008. Paul doesn’t want us to write old Perl, but only new and shiny Perl. This talk only covers practices that have come about since Perl Best Practices was released.

Object-oriented Perl is not awesome. Not even close. If you look at the old ways of doing it, all of them are either wrong, stupid, or both. The rest are too hard. There’s a simple way to fix this: use Moose. This module does so much of the infrastructure work of composing classes, it makes object-oriented programming enjoyable again.

Paul spent a lot of time giving a humorous, high-level overview of the features available in Moose.

The Moose module contains a huge number of extension modules in the MooseX namespace.

When I have a problem, I go down to the pub with other Perl mongers and bitch.

One of the limitations of Perl, that is exposed to Moose, is that not everything is an object. This means methods like push() or isa() can’t be called on everything. And checking types defeats the purpose of polymorphism. Enter the autobox module, which turns everything into an object. As a bonus, it operates in lexical scope. Moose exposes autobox through the Moose::Autobox module.

A module that Paul wrote, autodie, which is now included in core. This lexically scoped module removes all of the boilerplate code that goes along with trapping errors from subroutines.

Not only is Perl 5.10 awesome, but Perl 5.10 regular expressions are awesome. In particular, the introduction of named captures (via %+) made regular expressions extremely awesome.

Perl 5.10 also provides grammars in the regular expression engine. This is the basis for Damian Conway’s Regexp::Grammars module.

Referring to an article on SweeperBot in The Perl Review. However, there’s the problem of distributing a program that uses half of CPAN to users of inferior operating systems, such as Microsoft Windows. That’s where the PAR module comes in. It will pack up all of the modules used by the program, including the Perl interpreter itself if necessary, so a single, self-reliant file can be distributed to users who need it.

Remember to never optimize code. Programmer time is far more valuable than CPU time. However, when you must optimize code, profile first. The Devel::NYTProf makes profiling awesome.

Code reviews are important, but Perl programmers are lazy. Fortunately, the Perl::Critic module has read Perl Best Practices for you and will complain about where your code violates the practices in the book. At my day job, it does about half the work of code reviews for me, loudly announcing violations of the coding standards that I enforce with an iron fist.

If you find an awesome module, buy the author a beer if you have the opportunity. There’s also CPAN Ratings to leave feedback or perlthanks in recent versions of Perl.

The full title of this session is, 21st Century Systems Perl – the New Perl Enlightment for sysadmins

Introduction

While Perl isn’t dying, “PERL” most certainly is dying. This is a good thing, because it includes all the really crappy stuff, such as Matt’s Script Archive. Thank goodness for that. To be fair, this code would have been horrible written in any language. Remember, blame the artist, not the tool.

We have a very mature community, which means we also have very mature practices. We are also converging on a standard platform, even if there are more than one ways to do something.

Part 1: Minimising Developer Fatalities

As a developer, we should do what we can to make our sysadmins’ lives easier.

Right off the bat, we should use the local::lib module, which allows an application to use custom library areas without polluting the system installation areas. It can even work with /etc/skel. Matt is a big fan of using a local library path, included with the application, so it can be maintained separately from both the operating system vendor’s modules and even other applications.

Improve module installation using Module::Install.

Package modules for your distribution of choice using cpan2dist.

Improve the CPAN experience using App::cpanminus, which is amazing easy to bootstrap:

> wget cpanmin.us
> ./cpanm

Start using all of the modules associated with best practices by installing Task::Kensho.

Vendors are getting better at distributing Perl and keeping up with module releases. The Debian Perl team is the strongest, with Fedora lagging quite a bit far behind. Fedora is finally getting better, now that members of the Perl community have a say in the packaging of Perl and the modules.

After many debug sessions, Matt has come to the conclusion that mod_$lang is evil. Jamming languages into the web server is a bad, bad idea. However, actually hooking into the different handlers can be useful. Matt’s preference now is now FastCGI.

Part 2: Maximising Automation Banality

“In the systems world, shiny and exciting is not good.”

Use the autodie (in core as of 5.10) and the IPC::System::Simple modules to reduce the repetitiveness and the common errors of systems programming.

Use IO::All to fix the syntax and semantics of I/O operations.

Systems script shouldn’t need to be deployed. It should be possible to just drop the script onto a host and it will Just Work. That’s where PAR::Packer.

The full title of this talk is, Dist::Zilla – Maximum Overkill for CPAN Distributions.

Every CPAN distribution contains a significant amount of crap. It’s infrastructure used for the distribution tools.

ExtUtils::MakeMaker has been the traditional way to work on the infrastructure code. By necessity, it contains a lot of legacy, which can be cumbersome to maintain. Enter Module::Install, which can look in the expected places for the necessary information, such as the author name. But, the author still must write all the boilerplate. Module::Starter was written to address this, composing all the boilerplate on behalf of the author. There is so much boilerplate that, by default, Module::Starter also provides a boilerplate test to detect it.

Why are we doing all of this? How much repetitive work are we doing?

What can Dist::Zilla do for us? For starters, we can remove some files:

• LICENSE
• MANIFEST.SKIP
• Makefile.PL
• README
• t/pod.t
• t/pod-coverage.t

Leaving us with only our Changes file, our code, and our tests. The non-infrastructure parts. On top of that, Dist::Zilla does all of the boring distribution bits for us. It only handles the make dist command. It does not handle the make install command, which means the users who install the module don’t need all of the dependencies.

Dist::Zilla puts all of its functionality into plugins, which will be the meat of the rest of this session. It also uses a very simple INI-style configuration file.

The main command provided by the module is dzil build. This bundles the distribution, which will contain all of the infrastructure necessary for users to install the module. When building, it follows a simple work flow:

1. Gather files
2. Munge files
3. Collect metadata
4. Write out

There is no default configuration, but there is a Basic plugin bundle that will include all of the most common plugins.

What followed were examples of what the plugins can do. Of course, all of them are designed to reduce cruft—the non-code, non-documentation bits that we’re forced to maintain. The philosophy is the same one I advocate to anyone who will listen: computers are good at doing boring, repetitive tasks with derived data; why don’t we let them do more of that stuff?

I’ve followed @rjbs on Twitter for a while, and I’ve seen him talk about Dist::Zilla. I’ve wanted to try it out for a while, to simplify my distributions—both for CPAN and for my day job—but I didn’t realize until this session just how awesome the tool is. It’s a complete framework for managing Perl module distributions. Dist::Zilla will give my Laziness score a huge bump.

To be fair, this vagueness and my pessimism are precisely why these speakers have been invited to the O’Reilly Open Source Convention. Tim O’Reilly has a grand vision for the cloud, for ubiquitous computing, and the use of technology to help solve the world’s problems. I commend him for that. I hope this morning’s speakers do justice to his vision and that, if there are valuable lessons to be learned, that we learn them.

Today’s LAMP Stack

David Recordon (Facebook)

Over the last decade, the LAMP stack hasn’t been fundamentally updated. A cache, such as memcached has been added. Different languages (Perl, Python, Ruby) have been used in place of the original PHP. Even different web servers have been used in place of Apache.

Facebook created HipHop for PHP, which compiles PHP into C++. Creating native executables in this way reduces CPU use by a large factor (a number I didn’t catch).

There are alternatives for the database component in the stack, too. MySQL is ubiquitous at this point. Facebook doesn’t really use the relational bits of MySQL very much. So they have been using databases from the NoSQL family—Hadoop, according to the presentation.

David made a point I think a lot of people miss. When evaluating databases, or any other software, first look at what problem needs solving, then find a product that solves it in the correct way. Too often I see people advocating their preferred solution without even looking at the problem.

Data is the lifeblood of Facebook (and we all have our own opinions about that). They are able to use a plethora of Open Source tools to store the data, scale the data, and analyze the data.

This talk wasn’t very focused on the cloud, aside from Facebook being a nebulous site where people store their data without really knowing where it goes or how it’s used. I expect this was more for public relations, given all the bad press they’ve had. Not that anyone stops using Facebook.

Open SETIQuest – It Will Be What You Make It!

Jill Tarter (SETI Institute)

Jill started her talk by explaining what SETI is and why it exists, which I won’t go into here, since it’s just a Google search away. I used to run SETI@home a bit over a decade ago when I was in college and felt like using my computer as a space heater.

Jill is here, representing SETI, because she wants to involve the world in their search. SETI has classroom materials covered, but they are lacking in the social networking world. Jill wants people to first identify themselves as Earthlings, recognizing our place in the Universe.

SETI, with the development of the setiQuest community, hopes to use the vast resources available in the Open Source world to improve the project. These include physical resources, such as cloud storage and compute cycles, to human resources, such as programmers and analysts.

Cloudant has created a SETI stack on the Amazon AWS infrastructure.

Open Cloud, Open Data

Jean Paoli (Microsoft)

I’m always a little concerned when I see a speaker from Microsoft at OSCON. While I can imagine that there are employees at the company who genuinely embrace Open Source—and, presumably from this talk, open data—I can’t lay aside my suspicion. Microsoft does not have a benevolent history with competition, so when a representative shows up to talk about an open cloud with open data, I instinctively look for the company’s angle. What is their nefarious plan?

Jean talked about open standards and open data. Data portability, standards, easy migration and deployment, and developer choice. For some reason, when he talks about the “open cloud,” I have thoughts about Microsoft’s OpenDocument move a few years ago. Sure, parts of it were open, but the format as a whole was useless for non-Microsoft tools.

He claimed that Microsoft Windows Azure is an open and interoperable platform. I have a hard time swallowing that. The #oscon IRC channel was not kind in its commentary. A selection from the channel logs:

<b3gl> "Microsoft totally agrees..." as long as you pay your Windows, Azure and MSSQL license fees

<alapapa> standards are great…as long as they're ours

<dbrewer> wow, thanks Microsoft.  You think I should be able to use any language I want, I appreciate your permissions.

<b3gl> dbrewer: Notice he didn't say "We believe if you want to use Linux ...."

Public Static Void

Rob Pike (Google, Inc.)

Programming languages used to be relatively simple, but still fairly powerful. They’ve gotten considerably more complex and confusing. The C++ language was used as an easy target during the talk. Rob went on to bash various (in most cases deservedly) programming languages as a way to lead into what he called the renaissance of language design.

Many of the emerging languages are dynamic and interpreted, and there’s a false dichotomy that they are considered good while the static and compiled languages are considered bad. Part of the problem is that the latter class of languages are old, designed in a different age of computing.

Obviously, the end goal of this talk was to talk about the Go language, which tries to bridge the gap between the dynamic interpreted languages and the static compiled languages.

Toward an Open Cloud

Lew Moorman (Rackspace.com)

Lew’s talk was to introduce OpenStack. Rackspace took the internal software that powers their cloud and donated it to OpenStack. I wonder if this is something we can use at my day job to build an internal cloud. The stack is licensed under the Apache 2 license and they don’t use a dual licensing model, which sounds nice.

I was wrong, the talks weren’t really about demonstrating the wonder of ubiquitous computing and how we can move in that direction so much as a showcase of organizations in the cloud or using the cloud. It was really just one long commercial.

I’ve been told by those that attended the full tutorial that the first half wasn’t really worth attending. In fact, when I arrived at the beginning of the second half, I caught the tail end of the presenter demonstrating how he recreated Twitter using Cassandra, something he dubbed Twissandra. This seems to be the exercise of choice for any distributed system. In a way, that’s smart. Take a highly distributed system everyone is familiar with, explain the challenges faced by such a system, then demonstrate the effectiveness with which the software in question can solve the problem.

In any case, the second half of the tutorial was mostly dedicated to an explanation of how Cassandra distributes its data. The details and, frankly, the delivery weren’t that interesting for me, so I didn’t follow the discussion. It was too high level to keep my interest.

I still think that Cassandra is deserving of some investigation. I have a project in mind that it may be perfect for. At my day job, we have what is essentially a distributed, key-based data store. We’ve had to implement all of the data replication functionality. If Cassandra can alleviate the need to design and implement our own data replication and integrity systems, we can put more effort into the final delivery of the data, instead of its transmission.

For my final session of the day, I’m in Environmental Monitoring with Arduino and Compatibles. Since I attended the Arduino tutorial on Monday, I thought it would be fun to attend a session on using them.

The take-away points, presented up front for our convenience:

• Environmental monitoring is important
• Arduino is cheap and easy
• Small computers are fun

The Arduino is not just the chip and board, but the IDE used to program the board. It also, as I learned on Monday, has a very shallow learning curve.

Russell works for a company doing water monitoring of the Hudson River. He’s using his domain knowledge from his job to explain how one would do something similar on a smaller scale. The values he describes detecting, and the circuits used to take the measurements, are,

• Temperature
• Turbidity
• Salinity – can’t measure this directly, but salinity conducts and we can measure resistance

Now I just need to figure out what I want to monitor at home.

After a long break, an apple, a cup of coffee, and a beer, I’m back in the Perl track.

The full title of this session is, Scratching the 40-Year Itch of Inheritance with Smalltalk-style Traits.

This is not a tutorial. How to use traits is easy, but why to use them is a more complex discussion.

Inheritance is a very complex problem and an easy one to get wrong. Then people start doing things with multiple inheritance and, even if they’re not doing something deliberately stupid, they end up with diamond inheritance. Not only is this a problem, but it’s been a problem for a very long time—40 years, in fact.

Complex systems can lead to deep class hierarchies. When hierarchies are deep, in particular with a dynamic language like Perl, it becomes difficult to determine where a method came from. Even when its known where a method comes from, undesired behavior may be inherited. This becomes worse when multiple inheritance is used.

As systems grow, the problem becomes two-fold:

1. Class responsibility – larger classes are desired
2. Class reuse – smaller classes are desired

Inheritance, by itself, cannot solve this problem. So the solution is to
decouple the sub-problems.

Several solutions have been tried:

• Interfaces
• Delegation
• Mixins – incredibly popular

As expected by the name of this session, traits (or roles in the nomenclature of Moose) solve the problem far better than any of the above solutions. Much of the session involved showing real-world application of roles to clean up code at the BBC.

http://www.oscon.com/oscon2010/public/schedule/detail/13976

I finally left the Perl track. I attended Tim Bunce’s presentation on Devel::NYTProf at OSCON two years ago and, while there have been many enhancements made to module since that time, I expect this year’s talk won’t differ much from the previous one.

This session on Simple Cloud is being presented by IBM’s Cloud Computing Evangelist. The drivers behind this product (is it a product?) are the development and promotion of a standard cloud API. There is some relevancy with my day job, not only because of the possibility of using cloud services, but as a way of getting ideas for the API I develop for our engineers to interact with the batch compute system.

There are several levels of where we can work. The levels start at the wire, where we have to generate and parse data ourselves. From there, we have vendor-specific APIs, service-specific APIs, and finally service-neutral APIs. This last level is where we want to be.

The Simple Cloud API covers three areas: file storage, document storage, and simple queues. Once thought of in these simplified concepts, there really isn’t any reason the interface used by a program can’t be standardized. A program should no more need to concern itself with the implementation details of an individual cloud provider than it does the details of the file system of the computer on which it runs.

The API uses the Factory and Adapter design patterns, with a configuration file used by the Factory object to determine which Adapter should be created. These patterns are exactly what I’ve been looking at for the API I work on at my day job.

A demo of the Simple Cloud API followed. There wasn’t much to these demos. The first showed listing data stored at two different providers. The second showed queue manipulation.

After the demo, the Apache libcloud, which is getting a good deal of vendor support.

Unlike Monday, I chose tutorials on Tuesday that held some relevance to the work I’m doing. At my day job, we have a MySQL database backing a critical production system. We have spent years fighting with it and dealing with its failures and instability. I have a bias towards PostgreSQL, having used it in the past, and finding it a superior database to MySQL. That, however, is beside the point. What is pertinent is that I have been considering a complete redesign of the system, using PostgreSQL as the data source, and a tutorial on the built-in standby and replication capabilities coming with the release of PostgreSQL 9.0 is timely.

The slides for this tutorial were distributed to us when we registered. They are intended to stand on their own, serving as documentation if we later work on implementing the concepts presented here. That said, the information density of the slides didn’t at all detract from the presentation. As a hands-on demonstration, Chander didn’t project the slides very often and, when he did, only referenced them as he spent time explaining the material.

In order to better understand how PostgreSQL implements hot standby and replication, Chander first gave us an overview of how PostgreSQL manages the data a database. I’ll be brief, so this is probably not entirely correct. For efficiency, data is manipulated in 8 kilobyte pages stored in memory, in what is called the shared buffer pool. These pages remain in memory until the pool is exhausted, at which point one or ore infrequently used pages will have any changes written to disk and purged from the pool. This means that while the updates are stored in the pool, there is a (potentially long) window of time in which a crash will cause data loss. To prevent data loss, all update operations are first written to the write-ahead log (WAL) files. During a recovery operation, these WAL files can be used to play back any transactions that were lost in the crash.

Having these WAL files means that, from a given point in time, the database can be reconstructed. It’s not a stretch to shift the playback of these WAL files into real time on a secondary system. This automatically creates the possibility of a live replicated database, which can be queried in place of the primary database.

The rest of the tutorial was devoted to demonstrating how to set up and use warm standby databases, hot standby databases, and streaming replication.

I’m just back from lunch at Burgerville with Juan and Jonathan. On the way back into the convention center, I ran into Alasdair, who has been attending the hardware hacking sessions. That made me think that I may want to try to find non-Perl sessions to attend. After all, I tend to keep up with Perl news, so the sessions are of marginal usefulness. Unfortunately, nothing on the schedule looked very interesting to me. I was curious about the session on Open Source Tool Chains for Cloud Computing until I read the description. While it looked cool, it wouldn’t be useful for me in my work. The session would go through provisioning, setup, and maintenance of hosts, all of which we already have well-entrenched solutions for in my day job. So, I ended up back in the Perl track. My friends in the San Diego Perl Mongers group will appreciate that, I think.

Anyway, on to the session.

The name Perl 6 is a language specification, rather than any particular implementation. All of the references and links off-handedly mentioned in this post are available from the Perl 6 website.

Patrick is the lead developer of Rakudo Perl, which is the most feature complete and up-to-date.

Perl 6 has a language specification and a test suite. There are still many places in Perl 6 that are not being tested yet.

Rakudo * (Star) is scheduled to be released a week from tomorrow, targeted at being a useful, usable, early adopter distribution.

At this point, Patrick began to enumerate the new language features and how they work in Perl 6, such as variables, loops, interpolation, and so on. I won’t go into these here, since there are numerous places on the Web where this has been documented.

About half way through this session, I realized that “r0ml” was presenting in another room. If I’d noticed that before, I would have attended that session.

This talk could be titled something along the lines of “Lessons Learned from Project Management.”

Jesse Vincent is the current Perl 5 pumpking, which for the moment can be thought of as the project janitor.

People who say “Perl is dead” or that Perl hackers are “desperate” are behind the times.

There are a lot of exiting things happening that are not in the Perl core. Audrey Tang has said that “CPAN is the language, Perl is the syntax.” Like Piers in the previous session, Jesse enumerated a handful of things that make Perl awesome:

• Moose
• Plack
• cpanm – makes installing CPAN modules Just Work
• Devel::Declare
• Devel::NYTProf

While some of the coolest new things happening in the CPAN world, it merely scratches the surface of what is available.

About three months ago, Jesse uploaded Perl 5.12. Amazingly, no one has reported any critical regressions.

Jesse has been assured that Rakudo * will be out next week, on 29 July. However, Perl 6 will not replace Perl 5, which has paid Jesse’s mortgage for many, many years. Also, thanks to Perl 5.12, Perl 5.10 is no longer “too new to use.”

Perl 5.12 marks the latest release in the process of cleaning up the inernals and adding much desired features. Some of the highlights:

• Deprecations warn by default
• suidperl is dead
• package Foo::Bar 1.0; – better version import syntax
• Y2038 compliant – thanks to Schwern
• Unicode improvements; upgrade to 5.2
• Pluggable keywords
• Overridable function lookup
• Dtrace support
• Deprecated modules – Class::ISA, Pod::Plainer, Shell, Switch (but still on CPAN)
• Yadda, yadda, yadda operator

Jesse believes the best new thing in Perl 5.12 is the release process, including him as the pumpking. Twenty years ago, Perl didn’t use version control. He recommends learning from this mistake.

It took five years to release Perl 5.10, after burning through two pumpkings.

Before 5.12, maintenance releases contained all sorts of bug fixes and updates, but could not break binary compatibility. Doing so was a huge task, was very difficult, and, contrary to its name, is unmaintainable. Even without all this work, the pumpking’s job is a lot of work. Jesse really doesn’t want to burn out after a release of Perl.

Traditionally, the process of turning someone with the necessary skills to be the pumpking involves preventing them from using those skills and replacing them with management skills. It’s a shame.

The system is broken and Perl 5 isn’t going anywhere, so how can it be fixed? We can reinvent it, but that’s already being done by Perl 6. Alternatively, we can refactor it. There is no reason many of the skills and duties required of the pumpking can’t be delegated out to people with those skills. In effect, the most important skill and duty for the pumpking is project management.

The 5.9 releases, leading up to 5.10, were haphazard. The 5.11 releases, leading up to 5.12, have settled into a new release every month on the twentieth, with a couple of exceptions. The 5.13 series has followed suit. One of the reasons this was possible was documenting the entire release process.

Releases in the 5.12 series are on a fixed schedule, every three months. A release schedule has been created for 5.14, too.

One of the things I’ve learned working in an enterprise and my observations of the Fedora Project is that good project management is vital. Jesse Vincent is exactly what Perl needed and he continues to demonstrate that, with regular, high quality releases of Perl. What’s more, he is a good spokesman for the project, being able to come to OSCON and give a session on all of this detail in a cojent and interesting format.

After reviewing today’s session schedule, I quickly came to the conclusion that I will spend my entire day sitting in the room “Portland 256.” This is, apparently, where the Perl track is located.

Paul Fenwick introduced Piers in song, to the tune of Gilligan’s Island.

Piers switched from Perl to Ruby a while back and swore that he wouldn’t return to Perl until 6. Facetiously, the reason he switched to Ruby was the handsome community associated with it and he reason he switched back to Perl was the amazingly supportive community associted with it. He began with a point about programming style. We think of code as describing what we are doing, but in reality the majority of our code actually describes how we are doing it. This infrastructure code is noise.

More seriously, he absolutely hated unrolling the @_ variable in every function. In such a high level language like Perl, why must we pop arguments off the stack in the same manner we would in an assembly language? This leads to long subroutines, every single one containing anti-patterns designed to implement the language infrastructure, instead of the language doing the work for us.

Moose does a lot to improve writing classes, using a more declarative syntax. However, even within Moose methods we need to write the infrastructure code. The MooseX::Declare module solves this problem, giving method syntax a more declarative style. By moving the infrastructure code out of sight, we can better focus on what we are trying to do, rather than how we are doing it.

Piers proceeded to list the modules that “rock” and brought him back to Perl:

• Plack
• Devel::NYTProf
• Moose

Perl’s object-orientation absolutely “sucks.” However, this turns out to be a good thing. It allows very clever people to create modules that extend the semantics of the language. In a language like Ruby, which has a good object-orientation built-in, it’s essentially stuck. If, in the future better ideas of object-orientation are developed, they can be implemented in Perl far more easily than in Ruby. An interesting point: sometimes when the tool sucks, things are better. People develop layers of tools that enhance and extend the original.

It also helps that the Perl release schedule has accelerated.

Piers continued with a high-level, hand-waving explanation of how MooseX::Declare works. While not informative, it was entertaining. Including a video of Matt Trout attempting to hypnotize the room.

Piers ended by thanking the Perl community and expressing how good it feels to be back into it and developing in Perl again.

It’s Wednesday morning at the O’Reilly Open Source Convention, which means it’s time for the introductory keynotes. The first thing I’ve noticed this morning is how crowded it is. Certainly more so than when I was last here in 2008. I don’t know if that’s just because we aren’t being given breakfast in the expo hall this year, so everyone is crowded into the area outside the ballroom. Another thing I’ve noticed is the gender makeup of the attendees. While still overwhelmingly male, I have noticed more women in attendance this year. Diversity is good.

Without any further ado, we’re getting started.

Welcome

Allison Randal, Edd Dumbill (O’Reilly Media Inc.)

This year’s co-chairs welcomed us and talked a bit about OSCON this year. Obviously, there wasn’t a lot of content, but they did mention the Android Hands-on event being sponsored by Google tonight. I did register for that, since it sounds like it will be fun.

Keynote

Tim O’Reilly (O’Reilly Media Inc.)

First up is the namesake of the convention. Every year he presents his vision, not just for the conference, but for the future he wants to see. He has been steering his company away from being just a book publisher or a content producer, but a company trying to make the world a better place. He urges the Open Source community to think about the cloud. Don’t just think about Linux, or whatever project, but about the bigger picture and where we’re going as a society.

He is fascinated by the ability of technology to reinvent government, a concept he’s dubbed “Gov 2.0.” We fall into the cycle of thinking of government as a vending machine, something we simply get things out of, and get frustrated when we don’t. Over the last few years, he has been talking about government as a platform.

We shouldn’t think just about selling to the enterprise, but about building a better world. We all benefit when that happens.

Coding the Next Generation of American History

Jennifer Pahlka (Code for America)

The government doesn’t have to be this obscure, opaque thing we get stuff from. It can be a platform for us to work together. Currently, the majority of the municipal workforce is over 40, and a significant percentage will retire soon. This creates a huge age gap, which leads to a technology gap.

In Oakland, California, the city workers can’t search city council meeting notes online. The method of entering the data in the computer is to scan the written notes, which are impossible for them to index.

Code for America was created to encourage younger, technologically-savvy individuals to apply their talents to government. It’s designed to create technology to open up government, to make it more accessible to the citizens. It’s a little like the iPhone or Android ecosystems. Government provides the platform, essentially the data. We, the citizens, build the apps.

Keynote

Bryan Sivak (Government of the District of Columbia

Those in the government of DC are big fans of Open Source, running Linux among other projects. They’ve long talked about being committed to Open Source, partly to save the taxpayers’ money. Unfortunately, much of this commitment is all talk.

For any project used in DC, forms are required to be filled out, justifying the choice and the expense. On this form is the question, “What Open Source projects were considered?” This is often left blank and still slips through without comment.

Proprietary solutions tend to come with copious documentation and an implementation plan. Open Source projects are more open-ended, which requires people within the government to have that vision and that creativity. This goes back to the age and technology gaps mentioned previously.

It’s good that these challenges have been identified and are being addressed.

Got MeeGo?

Dirk Hohndel (Intel Corporation)

MeeGo is the result of the unification of Moblin and Maemo. It targets netbooks, handset, tablets, and just about anything designed to be more mobile than a traditional notebook. It offers a full client Linux Open Source stack, from the kernel all the way up to the user interface, including the flexibility to support proprietary devices.

Dirk went over the primary goals and philosophy of the project (to be completely open), then went on to describe the organization of MeeGo at a high level. This included both the technical building blocks and the relationship with upstream projects.

Is Your Data Free?

Stormy Peters (GNOME Foundation)

Many of us use completely Free software on our computers, some even insist on it. However, when it comes to online services, we’ve gotten lazy.

Free software was driven by two types of people. There were those who advocated that all software should be Free, that it should be available to all people, regardless of their means. There were others who used and advocated Free software because they wanted something that didn’t crash. It’s this latter It Just Works motivation that Stormy believes has caused us to get lazy about demanding Freedom from our Web services.

She asks how many of us control our own email or have alternative ways to access it if something should happen to the primary service. What if Twitter or Facebook decides to delete your account? What happens to your data? She then went through a few examples of alternative services that have open data policies, such as Identica and Tomboy Online (it’s funny, I don’t use Tomboy because I won’t use Mono).

How many of us have read the agreements when signing up for Web services? Do we know who owns our data? Can we back it up ourselves? Who owns it, both while we’re using the service and if or when we decide to delete our data?

Keynote

Marten Mickos (Eucalyptus Systems)

The shift to the cloud is causing computing to scale, both up and out, far faster and far larger than any of the previous trends (mainframes, minicomputers, or client/server).

Many of the Open Source licenses were designed in an environment where everyone runs software on their own computers, software that requires distribution to be useful. Today we’re seeing more services being offered by companies running software within their own grids. Users never run the software themselves but rather send data in and get data out.

Eucalyptus is designed to be a highly scalable platform for on-premise use. As someone who supports many thousands of hosts in many data centers, this product has intrigued me for a while. Unfortunately, I’ve never taken the time to investigate it. It’s nice to see that those behind the company are committed to Open Source, using the split model. Users are free to download and use the software, while the company sells a supported version to enterprise.

The keynote sessions at OSCON tend to drag on for a while, making it difficult to pay attention the whole time. But they are finally over for now. We have a break before the first session of the day. I’m going to try to get some work done on yesterday’s posts before starting on my long day of Perl sessions.

I’m really impressed with the wireless network today. It had its problems during the tutorials on Monday and Tuesday. Traditionally, the network becomes almost unusable on Wednesday morning. This year, however, I have been able to connect to the Internet and write this blog post without any frustration.

For lunch, I met up with some coworkers and some friends to head across the river for lunch at Old Town Pizza. I had a small sausage and mushroom pizza, and washed that down with a pale ale.

After the Arduino tutorial, having sat down for much of the day, I grew restless. I really wanted to take a walk. More importantly, I really wanted to make my way over to Rogue Ales Public House for some beer. So I called Jonathan and we made our way over there. We each started with a four beer sampler.

I started with the Chatoe Oregasmic, finding it to be a pleasant, light pale ale with moderate hoppiness. Upon tasting it, one of my coworkers commented that it was what he expected the pale ale, which he had ordered to be.

Second in line was the Double Mocha Porter. It had a faint mocha aroma, but very little of this made its way to my pallette. I could detect a hint of smokiness, if I concentrated on it.  For something advertised as a double mocha, I was disappointed.

Having enjoyed Rogue’s Dead Guy Ale in the past, I chose for my third beer the Double Dead Guy Ale.  I don’t think I was fair to this beer. The name made me think of Stone’s Double Bastard and the Double Dead Guy Ale is nothing like that. Even so, I found it smooth with a pleasant maltiness and light hop flavors.

Saving what I expected to be the best for last, I finished with the Brutal IPA While nicely hopped, I was left disappointed after building my expectations on what I consider to be its undeserved moniker. Once I got over that, I still found it to be a perfectly enjoyabl beer. It had mild malty notes and, like the other Rogue ales I sampled, it too was smooth.  I found it to be an all around decent IPA.  Since Juan wasn’t able to join us for dinner, I bought a bottle of the Brutal IPA to share with him later.

After I had finished my samples, it was the decision of those in my party that I was criminally without beer and that, to pay penance, I was to order the Issaquah Menage A Frog.  When the bartender told me it was only available in a 12 ounce glass, I suspected that an imperial style ale.  The aroma and taste soon confirmed this.  Coming in at 9% ABV, it was not as strong as some of the ales I occasionally drink back home in San Diego, but it went very well with the beer and cheese stew I had for dinner.

And now it’s late, just a few minutes until two o’clock in the morning. I should have closed my computer and gone to bed hours ago, but I refused to do so knowing that my first day of OSCON blog entries were unfinished. Hopefully, I will have more food and beer to write about tomorrow.

In the beginning, I was shamed.  While I tried and failed to follow the Linux installation instructions, my coworker, Debbie, was able to plug my Arduino board into her Microsoft Windows notebook and get the first example running.  When the udev tip didn’t work, things were looking bleak for my attempt to control open hardware with an open operating system.  Finally, a trip to Google landed me right back on the Arduno wiki at the installation instructions for Fedora.  Finally, I could upload code to my Arduino board.  After getting the initial example to work, I modified it to change the pattern of the blinking on-board LED bulb:

int ledPin = 13;

void setup() {
    pinMode(ledPin, OUTPUT);
}

void loop() {
    digitalWrite(ledPin, HIGH); delay(300);
    digitalWrite(ledPin, LOW);  delay(300);
    digitalWrite(ledPin, HIGH); delay(300);
    digitalWrite(ledPin, LOW);  delay(300);
    digitalWrite(ledPin, HIGH); delay(1000);
    digitalWrite(ledPin, LOW);  delay(1000);
}

While we were playing with our new toys, we were treated to the history of the Arduino project, some other open hardware projects, and some of the things people have done with them.  Unfortunately, I was too busy playing with my new toy to take notes on these things, so the history lesson, by way of Wikipedia, is left as an exercise for the reader.

The editor embedded in the Arduino IDE leaves a lot to be desired.  It’s like Microsoft Notepad with syntax coloring.  My coworker found a setting that forces the IDE to use an external editor.  Basically, all it does is to make the editing window read-only.  Files edited outside of the IDE are re-read when the code is compiled.  In short order, I was able to find a Vim syntax file for Arduino code files.

After the break, we were introduced to using the Arduino board in combination with a breadboard, which allows for the creation of more complex circuits.  I’m excited, because I still have the breadboard, components, and multi-meter I bought in college for a computer engineering class.  I’ve been waiting all these years to finally have an excuse to dig them out of the closet and put them to use.  The Arduino will be a fun learning tool when my daughter is older, too.

To commence our unstructured time, which would last until the end of the tutorial (and the day), we were shown a simple circuit to wire up between the Arduino board and the breadboard.  Using a copy of the first blinking code, we could acheive the same effect of blinking the external LED simply by modifying which pin was referenced.  I took this a step further and made my LED bulb pulse like the light on a suspended MacBook.

I’m glad I decided to attend the Arduino tutorial this year. I’ve just picked up yet another hobby I don’t have time for.

The version of Blender available in the Fedora 13 package repository is 2.49b, but the tutorial focused on the beta version of 2.5, which has a redesigned user interface and new and improved features.  A Linux version was available on the internal cache website offered by OSCON, but it was 32 bit.  I ended up downloading a copy from the Blender website (the conference wifi doesn’t start to get really bad until Wednesday).  Unfortunately, Blender proved unstable and would frequently crash with a segmentation fault.  Matthew had provided files to serve as starting points for each section of the tutorial, so it was relatively easy to follow along, even if I didn’t complete the previous section.

Matthew walked us through generating a simple animation of a flying saucer approaching a planet and hitting it with a beam of light.  We started with simple shapes, two spheres, one flattened, for the saucer, a cone for the beam of light, and another sphere for the planet.  From there we learned how to apply surfaces and textures, manipulate light sources, and perform a simple animation.

All in all, I think the tutorial was worthwhile.  If I had launched Blender without it, I would be lost.  I’m still lost, but at least I have some semblance of an idea about how it works.

At the beginning of the trip, I ran into a coworker, Juan, at the airport in San Diego, who was on his way to OSCON, too.  We weren’t able to sit together on the flight, but that worked out in the end.  A man was traveling with his son of around five years.  The son had the seat next to mine, while the father was several rows back.  I offered to trade seats with the father, so he could sit with his son.  One of the flight attendants bought me a beer for my trouble.  On top of all that, the we arrived in Portland earlier than expected.

After checking into our respective hotels, we swung by the Oregon Convention Center to register for OSCON and pick up our badges and associated crap.  Actually, a mug was included in the bag o’ stuff, which I can actually use.  Plus, the bag can be kept in the trunk of my car for use at farmers markets.

Finally, it was time for dinner.  Juan and I met up with a friend of mine from the San Diego Perl Mongers and hopped on the MAX to head downtown.  After wandering around aimlessly for a bit, I searched for Kells Irish Restaurant & Pub on my phone and we found it in short order, taking a seat out back in their new beer garden.  I washed a corned beef and turkey sandwich down with three pints of Mt. Hood Ice Axe IPA and one pint of Kilkenny Irish Cream Ale.  Shortly after we finished our food, we were joined by two more coworkers, who ordered some food of their own.  We spent some time doing what one does in an Irish pub, namely drinking and talking, then we made a failed attempt to find coffee.

That brings an end to OSCON travel day.  Tomorrow morning I will head to the convention center for breakfast and will hopefully run into more people I know (or will meet new friends).  I have two tutorials scheduled for tomorrow: Introduction to 3D Animation with Blender and Get Started with the Arduino – A Hands-On Introductory Workshop. I know these tutorials don’t appear obviously relevent to my job, but I’m looking at them as useful for relaxing and enriching.  One of the reasons I like to attend OSCON is because I return to work refreshed and with a state of mind more prone to imagining creative solutions.  So, tutorials outside of my immediate area of expertise are exactly what I need when I come here.