ZendCon ’09

Last year I had the privilege of attending ZendCon ’08 and next month I’ll be traveling again to Silicon Valley for ZendCon ’09, “the larget event of the PHP community.” At last year’s conference I met a bunch of amazing people from the PHP community, saw several really good talks, and was one of the first to become a Zend Certified Engineer (ZCE) in Zend Framework (the exam was announced at the conference).

This year I’m looking forward to seeing people in person again that I met last year and meeting others who I’ve only talked with online. The session lineup is looking good and I’m also very interested in attending some of the unconference sessions again. If you’re going to be there, let me know so we can connect.

PHP Users Group Social

Tonight (9/24) the Burlington, VT PHP Users Group will be hosting its first “social” event. We’ll be having a casual get-together at Madera’s in place of the typical meeting format. We’ve also extended an open invitation for non-PHP people to come and join us. The Vermont Code Camp earlier this month was a great opportunity for local technology and user groups to mingle and I think there is a lot we can learn from each other. So, PHP developer or not, I hope to see you this evening! You can RSVP up until 5pm tonight.

No Invisible Metadata

Yesterday I tweeted (link expanded):

Google officially ignoring keywords meta tags is a nice validation of @microformats “no invisible metadata” principle: http://tantek.com/log/2005/06.html#d03t2359

The link is to a 2005 post on Tantek Çelik’s blog where he expands on the microformats principle that “visible data is much better for humans than invisible metadata.” Google’s announcement the other day that they do not use the keywords meta tag in web rankings didn’t surprise anyone that knows anything about search engine optimization. We’ve known for years that Google ignores the keywords meta tag (Google’s Webmasters/Site owners Help has a page about various meta tags that doesn’t say anything about the keywords meta tag) but, until now, it’s never been official. Still, I think it’s a nice validation of the principles of microformats and will hopefully give people pause when considering hidden metatdata schemes in the future.

On a silo website or within a trusted network, hidden metadata can be useful. In fact, in Google’s announcement they mention that the Google Search Appliance has the ability to match on the keywords meta tag. At web scales, hidden metadata is critically flawed. How can you trust that the hidden metadata is in parity with the visible data? The hidden metadata may be intentionally inaccurate (e.g. keyword stuffing) or simply have fallen out of sync with the visible data. Within a silo website or a closed network you can trust the metadata to be true to the visible data it describes and you can enact policies to keep your metadata up-to-date. However, there are no trust models yet that would make this work at web scales.

Microformats are designed for “humans first, machines second” (another principle). This makes a lot of sense since all machines eventually serve humans, even if indirectly through many layers. If the machine doesn’t ultimately serve a human need then there is not much point in the machine’s existence (unless we are taking about sentient artificial intelligence). For direct human consumption, hidden metadata is completely useless. For machine consumption, hidden metadata can be useful. However, hidden metadata must at some point be transformed into visible data, even if in a completely different context than its associated visible data.

This was the case with search engines that did use the keywords meta tag in rankings: the original context for the visible data was the indexed document and the new context in which the hidden metadata was transformed into visible data was the rankings of engine results. As history tells us, this scheme didn’t work so well. Instead, Google used the visible data that is hyperlinks to determine rankings. From Tantek’s blog entry (emphasis added):

Lesson learned: hyperlinks, being visible by default, proved more reliable and persistently accurate for many reasons. Authors readily saw mistakes themselves and corrected them (because presentation matters). Readers informed authors of errors the authors missed, which were again corrected. This feedback led to an implied social pressure to be more accurate with hyperlinks thus encouraging authors to more often get it right the first time. When authors/sites abused visible hyperlinks, it was obvious to readers, who then took their precious attention somewhere else. Visible data like hyperlinks with the positive feedback loop of user/market forces encouraged accuracy and accountability. This was a stark contrast from the invisible metadata of meta keywords, which, lacking such a positive feedback loop, through the combination of gaming incentives and natural entropy, deteriorated into useless noise.

Vermont Technology User Groups

One of the great things to come out of this past Saturday’s Vermont Code Camp was the opportunity for people from various local technology user groups to connect with one another. People from the Vermont.NET User Group were there (the .NET group spearheaded organizing the event) and I also saw some friends from the Burlington, VT PHP Users Group. Based on turnout at the Ruby on Rails session, it looks like the Vermont Ruby On Rails User Group may be restarting soon. The Vermont Area Group of Unix Enthusiasts (VAGUE) was represented as well as the Green Mountain Oracle Users Group, the New England Adobe User Group, the VT SQL Server Users Group and the Vermont Software Developers’ Alliance (vtSDA).

User groups are a great way to meet new people, learn new skills and keep up with the latest trends in your field. Sometimes you’ll even be treated to pizza and swag. Whatever technology you work with, I hope you’ll find a local user group that you can attend — or start one yourself!

On a related note, the upcoming (10/26) Vermont 3.0 Innovation Jam looks like it will be a lot of fun:

[Showcasing] the coolest companies in the Green Mountains[, this is] not just a job expo. The event will examine the uniqueness of the state’s entrepreneur-founded creative technology companies while acknowledging the start-up drive that lives within each and every one of us.

Update (9/15): To clarify, the Vermont Software Developers’ Alliance (vtSDA) is not a user group but instead, “create[s] collaborative and knowledge sharing opportunities that promote and grow Vermont software businesses.” They are also a primary sponsor of the aforementioned Vermont 3.0 Innovation Jam.

Vermont Code Camp Heroes

By all accounts, the first ever Vermont Code Camp was a big success! There were 85 attendees, 19 sessions, and a whole track of non-.NET topics (not that there’s anything wrong with .NET!). A HUGE thank you to Rob Hale, Julie Lerman and everyone else who organized, volunteered and presented. Also, a big thank you to the sponsors and donors: MyWebGrocer, Green Mountain Coffee, Telerik, O’Reilly Media, TechSmith, Microsoft and, of course, the University of Vermont School of Business Administration for hosting the event.

Plans are afoot for the next iteration of Vermont Code Camp so stay tuned!

Resource-Oriented Web Services

Below are the slides from my presentation on Resource-Oriented Web Services at the September 12th, 2009 Vermont Code Camp:

Vermont Code Camp

This Saturday (Sept 12) from 9am-6pm will be the first ever Vermont Code Camp and it will be here in Burlington, Vermont at Kalkin Hall on the University of Vermont campus. While code camps are typically .NET focused, this one will cover a broad range of topics including .NET, PHP, Ruby and Python (full list of sessions). Some of the sessions include:

Hope to see you there!

Unit Tests Are Not About Testing

I had the suspicion for a while but it didn’t become clear to me until recently that unit testing really is not about testing. Sure, you are writing tests and there is certainly value in having “tests.” However, the real value of unit testing becomes evident when you stop thinking of it in terms of testing. If it’s not about testing then what is it about? Unit testing is really about defining behavior. Enter Behavior Driven Development (BDD):

It is not too surprising that it takes apprentice TDD [test-driven development] practitioners a while to realize that TDD is not about testing when all of the nomenclature surrounding it is described in terms of testing.

The aim of Behaviour Driven Development (BDD) is to address this shortcoming. By using terminology focused on the behavioural aspects of the system rather than testing, BDD attempts to help direct developers towards a focus on the real value to be found in TDD at its most successful.

If you’re using PHPUnit then check out the Behaviour-Driven Development chapter for more details on how you can use this approach.

Models of Software Acceptance

A little while ago I read Richard P. Gabriel’s talk on Models of Software Acceptance [PDF]. I couldn’t find a date on this talk but I think it’s rather old, at least in terms of technology. However, there is very little in there that seems dated and much of it is very relevant today. From the introduction:

Building business success on technology is not easy—myths abound based on common sense, tales told by those who have won, analogies to things like evolution, and appeals to inventiveness and innovation. When we look closely at how technology is accepted and how success is built on it, the picture is quite different, and the process of acceptance is both lengthy and unpredictable. In this talk we’ll look at the myths and the realities, we’ll look at many specific examples, and we’ll conjecture a set of principles that might work.

Those of us who use and build technology every day often don’t give much thought to technology acceptance. We’re always trying out the newest and latest technology and are frustrated that others aren’t keeping up with our efforts to bring technology forward. We’re often surprised by what technology does and does not get accepted by the mainstream. We wait impatiently for the rest of the world to catch up with us. A common meme on the popular technology news website Slashdot is, “Where’s my flying car?” Most people don’t want a flying car, at least not yet.

Many of the interesting innovation opportunities are in technology acceptance. Sure, Google has some of the most advanced technology around but how have they lost out to Facebook over Orkut and to Twitter over Jaiku? Both Orkut and Jaiku are owned by Google but Google’s likely superior technology platform does not necessarily equate to superior user acceptance.

The information in Gabriel’s talk is great news for startups and entrepreneurs. Focus on technology that is several years old, keep your design simple, and find a niche opportunity where a larger competitor can’t beat you at gambler’s ruin. Read the full talk [PDF] for all the details.

Social Coding

My first real introduction to Git and GitHub was at last year’s ZendCon. I’ve been using Subversion, a centralized revision control tool, for a few years now and it has changed the way I work. For example, I think in terms of changesets or “commits” that fix a defect, make an enhancement or complete a task in my codebase. It’s a workflow that has served me well.

I’d heard about distributed revision control tools before last year’s ZendCon. I thought it was a neat idea but didn’t really get what the advantage was over a centralized tool like Subversion. The folks from GitHub had a vendor booth so I thought I’d ask them why Git was better than Subversion. I forget exactly what they said (probably something about how branching and merging is so much easier in Git) but whatever it was it definitely made me consider trying Git.

The GitHub folks were wearing t-shirts that said, “fork you” and explained that on GitHub they encourage projects to fork. Typically in free/open source projects forking is considered a bad thing. It usually signifies some breakdown in the community when one project forks from another. However, with Git and GitHub it’s really easy to “clone” a project’s repository, hack away at some changes, and then “push” (or have “pulled”) your changes back to the repository you originally cloned. Git makes branching, cloning, pushing/pulling, and merging very easy and GitHub provides a place to host your repositories making this interaction with other people’s repositories very simple.

GitHub’s tagline is “social coding.” With distributed revision control each developer gets his or her own project repository. If your repository is public then anyone can come along and make a clone of it giving themselves their own copy of your project to work on. Assuming their clone is also public, you can track their changes and decide if you want to pull in work they’ve done. If you find yourself collaborating a lot with a particular person that you trust, you can give them the ability to push to your repository. With Git this actually scales to projects with lots of contributors. This may seem chaotic, pushing and pulling changes to and from decentralized repositories, but it’s actually a great way to encourage ad hoc collaboration.

If you want to learn more about Git you can read the Git Community Book, Pragmatic Version Control Using Git or the Pro Git Book. One last thing: if you’re currently a Subversion user then forget everything you know about how Subversion works. While a lot of the commands may be similar to Subversion and there’s a way to integrate with Subversion (git-svn), Git is fundamentally very different than Subversion. If you try and equate the two you’ll most likely end up confused!