The “challenge” issued by the organizers for 2018 was the topic of “Taking Back the Open Web,” and they wrote that they wanted presentations “that touch on whether an open web actually ever truly existed, what state it’s in now, consequences of a closed web, and how publishers may protect and encourage an open web.”  So I took them up on that challenge. 

It ended being a fairly complex talk, as I tried to link together Benedict Anderson’s take on nationalism from Imagined Communities to a number of concepts about what might make an “Open Web.” 

Results can be seen in the video below from WordPress.tv (slides here: Taking Back What and From Whom?). Not sure I exactly nailed what I was trying to get across – feels like the Anderson bits are too long and not relevant enough – should have just taken the notion of “imagined communities” in one slide and gone on from there – but I hope folks find it interesting.

A few notes on things I did not get to, as I rushed for time. 

First, in talking about “Free as in Speech” versus “Free as in Beer” and gratis versus libre, I mentioned “free as in puppies” and that I would come back to it. The point I wanted to make is that people selling proprietary software love to use the “free as in puppies” meme to try to contrast their platform to open source, by implying you’ll need to spend more money and time taking care of an open source platform than you will with their proprietary / closed-source platform. 

That’s nonsense, especially when it comes to CMS’s. Web properties powered by CMS’s all need care and feeding. The joke of the CMS is that CMS platforms don’t actually manage content: people do. They just provide assistance to those people or provide a platform in which they can work. 

In other words, at risk of torturing the metaphor, free puppies do require care and feeding (and discipline, and vet visits) – but so do expensive purebred puppies. Just paying money for something does not mean it won’t require care. 

Second, and this is especially important at WordCamp for Publishers,  let’s not let the goal of having an “open web” that encourages freedom cause us to make a different gratis versus libre mistake and determine that all websites publishing content must be free-of-charge. A “free press” does not have to be free of cost, and publishers exploring various revenue generating options – including paywalls and subscriptions of various kinds – are not working against the open web but within it.  Content, especially real journalism, takes investment to make, and we need to build into our notions of the Open Web ways for people to get paid for their labor. 

There were a number of other good presentations at WordCamp for Publishers on paywalls and revenue models – you can see all of them at WordPress.tv. 

Third, in the context of including other Open Web efforts, I mentioned the IndieWeb movement and commented that the IndieWeb efforts were in an early stage and mostly appealed to fairly techie folks, who build their own CMS plugins and code. That got somewhat widely retweeted, as though it was some kind of critique of IndieWeb for not being diverse enough. 

It’s true that IndieWeb efforts right now are more focused on and appealing to people who can code, hack, or tinker with their own sites – but that’s not the end game, and it isn’t anything the IndieWeb folks aren’t aware of. Check out their Generations page for more on how they hope to scale over time to more kinds of users, and, as a community, they are very focused on plurality of approaches as well as diversity and inclusion. My intent wasn’t to single the IndieWeb community out for criticism but in fact to encourage people to check them out as an example of an intentional community trying to address many of the issues of concern to the Open Web. 

If you’re in the Boston area and missed out on 48in48 but like the concept, you should also check out New England GiveCamp, which is coming up May 18-20, 2018, at BlueMetal in Watertown.

The two events, though sharing a focus on bringing together smart digital professionals (developers, designers, PMs, strategists) with non-profit organizations in need of support, are otherwise very different.

48in48 projects are built on top of a very controlled WordPress-based framework, with a preselected set of plugins and base themes. Most of the effort on the projects is focused on content production and configuration plus styling – very little actual back-end or even theme level development happens. This enables a high volume of sites to be produced, but might leave developers who want to get their hands dirty feeling less productive. 48in48 also puts the nonprofits through some significant pre-work before the event, gathering content and brand assets and documenting the nonprofit mission clearly – getting basically everything the team will need to build the site. Having done all the work upfront, the non-profits themselves don’t (generally) attend – the digital professionals have what they need to build the sites.

New England GiveCamp, on the other hand, isn’t just focused on WordPress, though a majority of the sites built in the years I volunteered were WordPress sites. GiveCamp projects often include more significant custom development of themes and plugins, as well as (in some cases) migrations across platforms. Unlike 48in48, GiveCamp actually requires a representative from the non-profit be available as part of the camp and encourages their attendance. There’s definitely more flexibility for the developer, though I can’t help but wonder if the more locked-down approach of 48in48 works better for non-profits who don’t have the technical infrastructure or management to consistently own and take care of self-hosted site and would benefit from a more managed, multisite, restricted option. 

My talk was titled “Distributed, not Disconnected: Employee Engagement for Remote Work.” I described some of the steps we take at 10up to cultivate ongoing employee engagement as a distributed company.

Here’s the video, embedded from YouTube with the start and end times set to just my portion. Full videos on YouTube: Day One and Day Two.

It’s a revised version of the talk I gave at Prestige in Las Vegas at the beginning of the year.

I’m eternally grateful to WordCamp NYC – it was the first WordCamp at which I spoke, and was the WordCamp where I first met Jake Goldman. You could say without WordCamp NY I might not have my current job. ;)

Since the conference, a number of the key videos have been published. I’ll highlight a few here, but many more are available on the conference site blog.

(Note: some NSFW language in this presentations – designers and content strategists can get, let’s say, colorful in expressing their passion. If you are easily offended tread carefully).

Is Design Metrically Opposed?

Jared Spool is a Boston area UX researcher, pundit, and founder of User Interface Engineering (UIE). He’s also a very entertaining speaker, tackling the issue of trying to reconcile metrics-based approaches with how we think about design traditionally.

Accessible User Experiences

Patrick McLean was one of the few speakers I did not know of before the event – but he does a great job explaining the broader notion of accessibility.

Training the CMS: Building a Better Authoring Experience

Eileen Webb is one half of Web Meadow, a content strategy consultancy and small New Hampshire farm. There’s a ton of useful info in this talk for people building sites for clients as well as for WordPress core and plugin/theme developers, in terms of how we can best lead clients to content management success.

Adaptive Content, Context, and Controversy

The ever brilliant and funny Karen McGrane on responsive design and why it is still the best strategy in the great majority of cases even when personalization / contextual presentation is desired. I wish she didn’t keep using WordPress as the strawman representing unstructured content, but she’s always worth listening to, if you ever get a chance.

Everybody Hurts: Content for Kindness

Sara Wachter-Boettcher, like Karen, is a consistently wicked smart voice in the Content Strategy community, and is working on a book on this very subject: the painful intersection of our content with unpleasant and difficult emotional states users might be in. It can be a difficult talk to watch – trigger warning for abuse survivors – as she dissects the assumptions we make in designing platforms and applications.

Honestly, I’d give a blanket recommendation here: any of the talks from this conference are worth watching, and the speakers worth following on twitter or elsewhere.

At NERD Summit, like last year, they have the presenter log into a google hangout account they control, and do the talk as a screen-shared presentation, recording audio directly from the local laptop mic.

It doesn’t give you the video of the speaker AND slides at the same time, but it is crazy effective and efficient – my video was live as soon as the talk was done!

I also sat in on the business panel – but that I guess gets recorded differently (video camera setup). Will post here if/when the video gets posted.

This script, which I use to get a true RSS feed with enclosures for video versions of podcasts who use Google Hangouts or otherwise post their videos to youtube, had been broken by Google’s deprecation of their old API as they rolled out v3.

In the old (v2) API, you could just make calls out to an http endpoint like this:

http://gdata.youtube.com/feeds/api/users/username/uploads

And you’d get back a response you could parse to see all the uploads under that username, out of which you could construct an RSS feed.

For the new API, you need to first generate a server key. Create a project in the Google Developers Console, enable the YouTube Data API v3, and then generate a server key.

For any given podcast, you need to find the relevant Playlist ID. In general, the easiest way is to use the Google API explorer youtube.channels.list, put in contentDetails for “part” and username under “for Username.”

In the results, you’ll see a JSON structure – you’re looking for “uploads” under “Related Playlists” – that playlistId will work with the script to find all videos uploaded by this user.

Configure the script with your API key and the playlist ID, and you get a valid RSS feed with enclosures.

Note: I’ve discovered the feeds produced don’t work with PocketCasts on my iPad – you just get the YouTube Device Support video – but they do work with Downcast.  My guess is they are doing some caching or other server-side stuff that interferes.

I’ve written now a couple of times about what I think the WordPress community can learn from Drupal, and specifically Dries’ keynotes at DrupalCon, which I always make time to watch.

Now it’s time to talk about some learning in the other direction.

The occasion isn’t Matt Mullenweg’s State of the Word talk from WordCamp San Francisco, though those are always worth watching, nor his recent interview on WP Tavern, though that’s also worth listening to.

Instead it’s a talk by Aaron Jorbin at WordCamp Philly on Why WordPress Works This Way. (The video isn’t yet up on WordPress.tv – I will embed it here when it is).

Embedded below are his Aaron Jorbin slides WordCamp Philly – click once on a slide to advance – once your focus is in the iframe you can use the arrow keys to go back and forth. (I’ve started on slide 35, which is where he starts to get into Philosophy Driven Development):

Jorbin did a fantastic job articulating how the philosophy of the WordPress project drives development, based on a clearly articulated goal of democratizing publishing, and a set of tenets for what that translates to as a development approach.

Out of the Box

The idea is that WordPress should provide immediate utility – should be usable immediately out of the box, without requiring excessive configuration or dependency management.

Whenever a new feature is introduced into WordPress, it has to be done in a way that doesn’t require excessive configuration before it can offer value – that’s resulted in the famous five minute install, and a focus on preserving that initial experience.

Of course as users climb the sophistication curve, there can be some “progressive disclosure” of more advanced options – exposed for example as filters or config file edits – but they should never be required to get core functionality working.

Design for the Majority

The majority of folks who will use WordPress are not developers – in fact they aren’t even necessarily technical. When design decisions (including decisions about features in core) are being explored, if they are not useful to the majority of users they probably don’t belong in core.

A feature that a majority of users disable is not a feature, it’s a bug. Jorbin’s own first patch was rejected – but he now realizes that was the right decision.

The proper persona for which a CMS is designed is not the developer community who will use it to build sites, but the end user community.

Decisions, Not Options

Jorbin described Havoc Pennington as perhaps the most important contributor to WordPress who has never contributed code. (See his writing On Preferences or Nacin’s post from 2011 on the same topic).

Jorbin connects this to the question of Auto Updates – there was never even a discussion of this being an option a user has to enable – because every option imposes a design, technical, and cognitive cost on the project. (Of course this doesn’t mean auto updates can’t be turned off – just that this isn’t exposed as an option in UI, it requires a filter).

Clean, Lean, and Mean

Jorbin didn’t specifically address this one, or highlight it on a slide, but obviously his examples (“sometimes not adding a feature is a feature” are consistent with this value as well.

Striving for Simplicity

This means recognizing that ease of use matters – in a core strategic way, not as an afterthought or to be added once the core feature set is in place. Jorbin uses the removal of the link manager (which was done in such a way that new installs don’t get it, upgraders had it removed if not used, but folks using it kept it) and the more recent update to link pasting.

(If you haven’t noticed, in WordPress 4.2, highlighting some text and pasting a URL from the clipboard makes that text a link to that URL – an interaction so simple and intuitive that once you see it you wonder why it didn’t always work that way.)

This also relates to accessibility – simplicity and accessibility are often aligned, as simpler interfaces will be more easily made accessible.

Deadlines are not Arbitrary

Jorbin described the temptation to delay a release for that “one-more-feature,” and how that can become a quagmire that delays the release of truly useful functionality for end users. Getting functionality in front of real users in the real world as early as possible gives us the best chance to iterate on it.

Anyone who has dealt with the four year cycle of Drupal 8 development, with many times where it was declared almost ready, or about to be released, can understand the frustration of end users who are trying to make decisions and plan.

Sticking to a more frequent, iterative release cycle doesn’t mean releasing poor quality software, it means not allowing “one more feature” to hold up all the existing improvements ready to be released.

Imagine if WordPress had tried to hold back 4.2 or 4.3 in order to get the REST API integrated – since it is already available as a plugin, there’s no need to wait.

The Vocal Minority

We’re all used to the 90-9-1 rule: 1% of the internet creates content on the internet, 9% interact with it (comment on it, respond, share, etc), and 90% just watch.

The trick is to recognize that the people expressing their feedback most vocally in the context of development discussions aren’t actually the majority. (The majority of users are non-technical, and don’t spend time in development discussions).

WordCamps and WordPress meetups have done a wonderful job of encouraging regular contact between developers of the platform and real end users: at the happiness bar, via WordPress.com as a widely used platform, and via specific outreach into the user community.

Jorbin highlighted all the things that were once controversial developments: Multisite, Menus, the Customizer, Inline Plugin Updates, Emoji support. (Of course emoji support wasn’t just about emoji support but also fixing a critical security issue).

The point isn’t that the development team (core contributors) should ignore feedback from other developers, but that we should always seek feedback from end users and realize that there often is a majority that isn’t speaking up.

Our Bill of Rights

Jorbin concluded by pointing to the one thing missing from the WordPress development philosophy – a specific articulated expression of what kind of community we want to design/encourage/shape. He pointed to Drupal’s values (“Teamwork, innovation, and openness in our community”) and Joomla!’s vision (“A community that is enjoyable and rewarding to participate in”) as counter examples.

(Recently the Django community published the Django Community Diversity Statement as well)

We do have a “Bill of Rights” in WordPress, but it speaks more to individual rights, based on the GPL and the four freedoms.

What does this mean for the Drupal community?

I’ve often heard the Drupal community described as a do-ocracy: whoever can do the work has more influence and gets to decide. There’s a certain appeal to that, in the sense that it aligns with the open source ethos of “patches welcome” – ie, if something is important to you, you should be willing to devote some of your own time to fixing it.

The problem, of course, is that often the actual users of the software aren’t able to do the work. I don’t mean to imply the Drupal community doesn’t listen to users – in my experience there is a tremendous interest in getting user feedback and trying to help solve end user problems – but that the Drupal community sometimes seems to prioritize the desires of developers and sitebuilders over the needs of the non-technical majority.

The WordPress community specifically and concretely articulates a set of philosophies which say that the goals of end users are more important than developer desires or technical purity.

WordPress works very hard to keep complexity hidden “under the hood.” In Drupal, very complex administrative UIs are common. There’s no doubt a Drupal power-user can use those complex UIs to produce some complex structured content types and relationships (along with a complex set of module dependencies and configuration for those which can be hard to replicate, share, or manage).

In WordPress, the custom post type creation UI isn’t enabled by default – you have to write code (or leverage plugins) to get to custom content types. But that also means you don’t paint yourself into a corner as a user without fully understanding the underlying API.

I think it’s telling that there really isn’t a “site builder” role in the WordPress community the way there is in Drupal. There are folks who build sites – designers and developers, including front-end developers and web developers – but they aren’t site builders in the Drupal sense of being power users of the administrative interface.

I’ve often said Drupal suggests using 10 modules and a “recipe” for configuration for how they all relate to each other to avoid writing 10 lines of PHP code. WordPress will encourage you to write 50 lines of PHP code to avoid one configuration step on the user.

(See my talk on Structured Content in WordPress and Drupal from NERD Summit 2014)

I’ve attended most of the events in the series – I think I missed one or two due to travel – and I’ve always been impressed by the quality and usefulness of the conversation. Hopefully I won’t be the exception to that rule. ;)

My fellow panelists will be Rebecca Marani from Boston Interactive and Adam Gesuero from Image Conscious Studios.

If you’re in the greater Boston area, come say hello. (register here)

Venue: Boston Interactive Headquarters
Address: Schrafft’s Center at 529 Main St, Suite 212 Charlestown, MA 02129
Date/Time: Tuesday June 16th at 6:00pm

tl,dr; version

What can the WordPress community learn from the state of Drupal?

• The Drupal Association, which organizes DrupalCon and promotes Drupal adoption via marketing and developer outreach – offers a model for the potential evolution of the WordPress Foundation
• Outreach is critical. We can’t just speak to the WordPress community but need to reach out to potential users/customers and sell the benefits of the platform in a language they understand
• A willingness to experiment – with fundraising approaches, with the hiring of paid teams to supplement the open source core project (Mark Boulton design’s work on Drupal 7 for example) – has helped the Drupal community move forward. This doesn’t mean all those experiments would work for WordPress, but we should be open to new approaches
• The potential for organizational and client attribution on contributions is an interesting idea for rewarding companies who give back – though with caution about unintended consequences in terms of motivation
• There are benefits to the epochal release cycle from a marketing point of view – differentiating the old platform from the new. I don’t think WordPress should change to a four year re-architected platform cycle, but we should be doing a better job of articulating the more complex platform WordPress is today

The Driesnote

I’ll apologize in advance for the length of this post, but there’s much to cover.  The Driesnote from DrupalCon 2015 in LA has been published to YouTube and Slideshare:

I’d highly recommend watching it end to end, whether you think of yourself as part of a Drupal community or a WordPress community.

Some interesting takeaways for the WordPress community

My impressions here are driven by my experiences over the last 8+ years in both communities. Though I now spend the majority of my time with WordPress, I worked with and in Drupal for many years, and have great fondness and respect for the communities of people working on Drupal. (Per Drupalcores, I even have 3 commits in Drupal 8 core under my drupal.org username jeckman).

The intent is not to say the WordPress community should be more like the Drupal community, nor that the Drupal community should be more like the WordPress community, but that both can learn from each other. (And of course neither is really a single community – both are made up of multiple internal communities that sometimes share interests and sometimes compete).

Drupal Association vs. WordPress Foundation

The most immediate thing you’ll notice is that the first 15 minutes of the video isn’t Dries but an intro by Holly Ross, the Executive Director of the Drupal Association. The DA is similar to the WordPress Foundation, describing itself as:

an educational non-profit organization that tasks itself with fostering and supporting the Drupal software project, the community and its growth.

Dries retains ownership of the Drupal trademark, but the association has a right to use and defend the usage of the trademark; similarly, he retains ownership of the drupal.org domain, but allows its use by the association. (Automattic transferred the trademark for WordPress to the Foundation in 2010).

Unlike the WordPress Foundation, though, the Drupal Association feels more community driven and accountable: holding open board meetings, electing leadership from the community, publishing budgets and minutes, etc. Check out their pages on accountability, meeting minutes,   and the 2015 elections.

In part this is the legacy of how the DA came to be – during what Dries described as the great server meltdown of 2005. This necessitated community fundraising to buy servers to host drupal.org – and in the absence of a dominant commercial company behind Drupal (Dries’ company Acquia would not be formed until 2007) there was a need for a foundation to take more ownership of the project’s community assets. In contrast, the WordPress Foundation was established in 2010, five years after Automattic.

(The Drupal community refers to “dee-dot-oh” for Drupal.org, in much the same way the WordPress community refers to “dot-org” for WordPress.org or “the make blogs” for make.wordpress.org).

The WordPress Foundation did publish a 2012 Tax Year review  and said they “hope[d] to publish 2013 data sometime in the first half of 2014.” But overall the governance of the Foundation has been far less transparent and offered fewer clear paths to leadership for community members. (Could make.wordpress.org be owned by the WordPress Foundation the way Drupal.org is owned by the Drupal Association? Could the WordPress Foundation own organizing WordCamp US?). Of course community members can and do take leadership roles as volunteers in various community subgroups: training, community, meta, documentation, and the like – so maybe it is more an issue of clarifying the relationship between the community of volunteers, the Foundation, and Automattic – a perennial topic of fascination in the WordPress world).

To be clear, I’m not suggesting or implying the WordPress Foundation or Automattic has done anything inappropriate or unseemly. I think the Foundation has done tremendous work shaping and supporting WordCamps and other training opportunities.  I’ve personally benefited from their guidance on multiple years forWordCamp Boston.  Further, the WordPress Foundation has (through make.wordpress.org and community outreach) always been engaged directly with the community, especially in relation to WordCamps.

I do believe, however, that a more transparent and democratic approach to the WordPress Foundation’s governance and engagement with the community would be a step forward. It isn’t that I don’t believe the Foundation has the best long-term interest of the WordPress project at heart – I honestly do, and have admired the work the Foundation has done – but that open source communities tend to view secrecy as pathology. A more democratic function with specific and visible paths for community involvement (not just as volunteers but as leaders) could also accomplish more.

Promoting Drupal 8.0

The second thing I noticed was the approach the Drupal Association takes to promoting Drupal. Check out the landing page for Drupal 8 – including downloadable infographics, and specific sub-landing pages for developers, sitebuilders, CIOs, marketers, content administrators, and themers.  (OK, so the “themer” and “sitebuilder” terms are a bit inside baseball – terms not really used in the same way outside Drupal – but still a strong attempt to market the software somewhat similarly to how proprietary offerings are marketed).

There’s also an introductory slideshow (61 slides) folks can use to walk clients/prospects through what is coming in the next release.

Drupal 8 Accelerate Program

Finally, the DA is also driving the Drupal 8 Accelerate program, raising over $200,000 to help push Drupal 8 over the finish line. (To be clear the DA is supporting the program, while the core maintainers actually get to decide what to support with the funds).  It’s an interesting approach – not sure it’s one I’d like to see replicated in the WordPress community. We’ve seen our own share of crowdfunding campaigns and other mechanisms for funding core development and plugin development. I like that the program is able to award grants to folks who might not otherwise have the opportunity to dedicate themselves to contributing – which theoretically helps keep development more democratic.

I’d worry though about the message this sends to volunteers and to the community at large – that the program was necessary because the contributions of the existing teams weren’t enough.

Aaron Winborn Award

Real communities are made up of passionate, motivated individuals. Unfortunately one thing the WordPress and Drupal communities share is that sometimes the individuals we come to know and respect pass away.

The Drupal community chose to honor Aaron Winborn with an annual award, designed to recognize “an individual who demonstrates personal integrity, kindness, and above-and-beyond commitment to the Drupal community.”  The award includes a scholarship and stipend to attend DrupalCon with recognition during the event.

Providing more ways for the community to officially recognize each other, as well as help fund travel to events (which the WordPress Foundation has also done as travel scholarships) is a great way to memorialize those we’ve lost in the spirit of their contribution.

Dries’ Lessons

The majority of the Driesnote intertwined a history of how the software came to be and reached maturity alongside a set of seven lessons extracted from that history:

Each of these lessons could also be applied to WordPress:

1. Everyone Lives By Selling Something

Early in the history of Drupal, Dries reached out directly to Jeremy Andrews from KernelTrap.org and pushed Drupal as a potential solution. Dries traces the downstream impact of that on the community to show the impact of one early bit of advocacy.

It’s an excellent reminder. It’s not that commercialization is more valuable than community effort, but that we need to be passionate advocates for the things we care about, whether that’s platform adoption for WordPress or a specific direction in the community. We cannot take a “build it and they will come” approach but need to consistently strive to build in the direction(s) we’re passionate about.

2. Improving User Results Results In More Users

Dries recounts the Dean Spaces -> Civic Spaces history, and traces the impact that ultimately had on the community. The more we make any platform easy to use, and empower our end users, the more users we can attract.

Cultivating and celebrating successes in the community isn’t just about making those inside the community feel good, it’s also about speaking to those outside the bubble and demonstrating the power of the platform.

3. If You Attract Amazing People, Prepare To Be Amazed

The community is ultimately the sum of overlapping communities, each of which itself is ultimately made up of people. There’s a long-tail of contributors of course, but the power of a well placed individual to have a huge impact shouldn’t be underestimated.

While retaining our humility, of course, let’s celebrate some of the amazing folks in the WordPress community.

4. Recognize Trends Early And Embrace Them

Paying attention to the broader web community and open standards community is part of what drove Drupal’s success (and of course WordPress’s as well). Following what is happening with other platforms (open source and proprietary) and digital businesses is a critical part of ensuring the long-term future of the platform.

Much of that innovation will happen at the edges not at the core – leveraging plugins and APIs to enable support that later gets considered for integration to the core platform.

5. If You Want To Go Far, Go Together

This one will sound familiar to many in the WordPress community from iThemes’ Cory Miller.

Dries associates this with the growing commercial ecosystem around Drupal, including Acquia, and the decision to hire Mark Boulton Design for Drupal 7, as well as usability studies conducted at the University of Minnesota on Drupal. Recognizing the need to cultivate certain kinds of expertise and being willing to bring others into the community even through unusual approaches was key.

6. Honest Disagreement Is Often a Good Sign Of Progress

Good community management doesn’t seek to eliminate conflict or disagreement but to channel it toward productive paths. We have to have a community that can support legitimate disagreements but not let those disagreements stall progress.

WordPress is not well served by trying to be all things to all people, but with a simple out-of-the-box experience and powerful APIs (which can be safely build upon by development teams) it can serve a wide variety of audiences.

7. Obstacles Don’t Block The Path, They Are The Path

Dries walked through some of the challenges the project has faced as it has grown: how the cost of contributing goes up (as project complexity grows) and the benefits of contributing shrink (as the pool of contributors grows).

The Drupal community has experimented with several approaches to addressing this:

• Reducing “costs” of development: better project governance, integration of symfony, twig, and guzzle, having Drupal.org maintained by the DA instead of core developers, etc.
• Adding “selective benefits” for contributors – enabling individual contributions to indicate organizational credit and customer credit as well as volunteer. This would enable various kinds of badges and credits to the sponsoring organizations (see below).
• Fundraising – to enable bounties on specific bugs and to accelerate development on key blocking issues.

The “organizational credit” item is an interesting one for the WordPress community to consider.

Boone Gorges’ keynote at WordCamp NY 2014 and San Francisco 2014 both included a high level analysis of where code contributions to WordPress come from, including individual freelancers/independents as well as those working for large agencies (like 10up). When we track commits/props at the individual level, that obscures the fact that an individual might be contributing as a paid employee of an agency, for a client of that agency, or simply as a volunteer. 

I like that the model the Drupal community has developed allows for significant granularity of “attribution” – a single account might be working on behalf of different organizational sponsors or sometimes on their own.

Having organizational attribution in the system at this level would allow for different kinds of display of organizational involvement. Dries shared an example mockup of how this might work:

As an agency CEO, I love the idea that we’d be able to differentiate against other agencies that use WordPress but don’t contribute to it. As a community member, though, I worry about the unintended consequences of such a move in terms of motivation.

I don’t want people contributing to WordPress in order to get better ranking in a directory or credits in a list for their company. I want people contributing because they’re passionate about making the software better and enabling end users.

This approach also might over-favor code contributions over meetup and WordCamp organizing, forum support, documentation, marketing, themes & plugins, and other kinds of contribution we see throughout the community.

The Big Reverse of the Web

The final section was about what Dries has been calling the big reverse of the web: the broader shift from a pull model (you go find what you are interested in) to a push model (what you are interested in finds you). He articulates in a series of slides why he feels Drupal is well positioned to capitalize on and support this shift – supporting rich profiles for users, structured metadata for content, and flexibility of delivery to multiple endpoints, as well as more complex caching strategies for dynamic personalization.

It’s a compelling argument, though I think it overstates the replacement of pull by push, and I’m not certain I find all the examples compelling. It does put the platform in a context, and outlines a direction for the platform’s development – even perhaps a justification for the kinds of complexity the platform has chosen to introduce.

Of course WordPress is also well situated to support this trend, with custom post types and taxonomies, the REST API and ongoing efforts around how metadata is edited and stored.

Matt’s vision, focused on the broader and more general “democratizing publishing,” grounds the WordPress project core in a similar fashion. It’s more of a “big tent” approach in political terms – capable of incorporating and being in line with a broader set of community goals, less narrowly defined. That said, the “right information to the right people at the right time via the right channel” may be a mission that resonates more in the market, for organizations with complex communications goals.

When will Drupal 8 be done?

Of course, what many people are really looking for in a Driesnote is the update about Drupal 8 readiness. In some ways this is absurd, since there are numerous and frequent public updates about the state of the release. Nevertheless, it is a very public stage for the project leader to make pronouncements, so folks pay attention.

Stretch goal for Drupal 8 release: Barcelona (Sept. 21-25 2015)

Dries identified this as a stretch goal – achievable but not easy, and not achievable without additional help from the community.

This is perhaps the starkest contrast between Drupal and WordPress – the idea that Drupal 8 has been underway for the past four years (started officially in March 2011) and is still not past beta status.

Drupal takes an “epochal” approach – where the major version numbers (6, 7, 8) represent fundamentally re-architected platforms, breaking backward compatibility for modules, themes, and APIs in order to create new possibilities.

WordPress takes an “incremental” approach – each release is simply another iteration on the underlying platform (so 4.0 is no more different than 3.9 than 3.9 was from 3.8). There is a significant focus on backward compatibility, deprecating functions and APIs and giving plugin, site, and theme developers significant time to adjust before killing deprecated approaches.

The benefit of the Drupal approach is they don’t have to carry technical debt from one platform into the next, and can fundamentally shift the architecture, as they’ve done between Drupal 7 and Drupal 8, rewriting core APIs entirely.  The benefit of the WordPress approach is that you don’t have to completely rebuild your site(s) or application(s) when a new major version gets released. (There is no “migration” path from WordPress 4.1 to 4.2 because there is no need).

Honestly I’ve come to greatly prefer the WordPress community’s approach, given the length of time and effort the complete re-architecture represents both for the community and for the end users / clients.

There is something to be said, however, for the marketing benefit of the completely new platform. I’ve often talked to folks dismissive of WordPress only to find their experience was back on 2.8 or so era WordPress. There’s no simple way to say “that was the old platform – it’s all new now” as cleanly as the break from Drupal 6.x to 7.x. It requires more complexity to point to milestones like the merge of mu, or custom post types, or the REST API.

Your takeaways

Assuming you’ve had the endurance to make it through this entire post AND watch the keynote, what are your takeaways?

Two recent posts got me thinking about the Drupal community and the WordPress community.

First, Mendel Kurland (whom I’ve been seeing at every WordCamp lately from London to Maine to Minneapolis) wrote on WP Tavern about “A WordPress Veteran’s Take on DrupalCon LA“:

As I flew from DrupalCon Los Angeles, CA to WordCamp Maine, I thought a lot about what the Drupal and WordPress communities could learn from each other. WordPress and Drupal are two community-built platforms and each community is powerful. We stand to learn a lot from each other, because all open source projects matter.

It’s an experience I’ve had many times, having spent much of the last 7-8 years in both communities. (I attended DrupalCon each year from Boston in 2008 through Portland in 2013, and spoke at a number of DrupalCamps throughout the Northeast, while also organizing WordCamp Boston and speaking at WordCamps all over the US).

I used to joke about wearing my WordPress hoodie to DrupalCamps, and my DrupalCamp shirts to WordPress events – but the reality was, in my experience, there was very little overlap in attendees. At Drupal events, people would joke about WordPress as being “fine, for a blog,” implying or sometimes stating outright it wasn’t powerful enough for “real” web needs. At WordPress events, people would joke about Drupal being big and expensive, and fine if you had a team of twelve developers and 6 months or more to throw at a site build.

In reality, the thing which stood out the most to me was how little the members of each community actually knew about the other – as communities or as software projects. (I also spent time in the Sitecore community – where the gap is even greater. At open source events it is common to hear “no one really uses .NET anymore” but at .NET events it is common to hear “businesses don’t really use open source.” Both, of course, are demonstrably false).

The second recent post that spurred me to write was when Dries Buytaert covered the acquisition of WooCommerce by Automattic, concluding:

To me, this further accentuates the division of the CMS market with WordPress dominating the small business segment and Drupal further solidifying its position with larger organizations with more complex requirements. I’m looking forward to seeing what the next few years will bring for the open source commerce world, and I’d love to hear your opinion in the comments.

In some ways Dries’ take on the acquisition actually mirrors my own. The acquisition of Woo by Automattic will improve the ability of WordPress as a platform (and at some point one assumes WordPress.com as a service) to compete with Squarespace, Wix, and Shopify at the level needed by consumers, prosumers, and small businesses. (I also agree with Brian’s coverage at PostStatus – ultimately some of the WordPress.com VIP customers will want ecommerce).

On the other hand, though, I can’t help but see Dries’ post as a not-so-veiled message I’ve been hearing for years in the Drupal community: WordPress is for small businesses, Drupal is for enterprises.

Obviously as the CEO of an agency focused on designing, architecting, and delivering content management solutions for enterprises on WordPress, I take exception to that message. WordPress can be is leveraged regularly by enterprises.Data from places like BuiltWith and W3Techs shows the dominance of WordPress extends well beyond the small business sector, and remains strong even when filtered to just the top 10k sites by traffic. (One can quibble with the methodology for measurement here, as with anything at web scale, but I don’t see anyone claiming Drupal having a similar dominance of a filtered slice). Of course many large organizations end up using both in different scenarios, often alongside a half-dozen other platforms.

Drupal, historically, was also a contender for small businesses, non-profits, and independents. My first Drupal-based site I built from the ground up was for a local vegan society, and I later regularly built Drupal sites for academic departments or programs and other non-profits. Within the Drupal community there is a very vocal segment which feels Drupal is at risk of betraying its commitment to smaller organizations.

In other words, in both communities there are a variety of smaller communities of interest, whose interests sometimes overlap and sometimes diverge. There is no single, monolithic WordPress community and there is no single monolithic Drupal community.

WordPress, as an open source project, has a defined philosophy of development which includes “Design for the Majority,” “Out of the Box,” and “Striving for Simplicity.” Each of these in its own way (plus the often stated importance of backwards compatibility) represents a desire to serve the broadest majority with a simple clean core and a well defined set of APIs for plugin developers. That philosophy, combined with Automattic’s highly visible services for consumers, can lead to a perception that WordPress doesn’t serve the enterprise market. (Of course Automattic also offers WordPress.com VIP, and there are, in addition to 10up, many agencies, hosting providers, and other third parties serving the enterprise market explicitly).

Growing broad adoption of WordPress as a platform is generally valued by the community more than specific targeting of one market segment over another. Matt Mullenweg’s approach and philosophy has always supported that, across both his role at Automattic and his role in the WordPress project.

In the Drupal community, Acquia (Dries’ company) has pushed hard and fast in the direction of the Enterprise market, from day one. The initial announcements around Acquia positioned them as akin to the way RedHat serves the Linux market. That influence, supported by many other agencies (and individual agents) in the community, has pushed the Drupal platform in version 7 and even more so in version 8 (still due out soon), in the direction of what are perceived to be “Enterprise” concerns around technical architecture. (So much so, in fact, that there is a fork in the Drupal community, called Backdrop CMS, which is designed to better serve the smaller organizations and development teams for whom Drupal has become unnecessarily complex).

My point is not to counter Dries’ “WordPress is for small business; Drupal is for Enterprise” with my own “WordPress can do both more effectively than Drupal can do either” – though I guess I’ve made my own choice clear by joining a WordPress-centric agency and skipping DrupalCon 2014 and 2015.

I do still believe the WordPress community and the Drupal community can learn a lot from each other: about technical architecture, about the user experience of content management systems, about community governance, about how to design and hold conferences, about how to sell effectively against proprietary content platforms, and about how to keep innovating while moving forward large communities of contributors and stakeholders with (sometimes) competing interests.

Ultimately maybe the best thing to recognize here is that neither community is monolithic.

There are, in both the Drupal space and the WordPress space, multiple communities, with interests that often overlap and sometimes compete. The open source nature of both projects means that often, those communities within communities can broadly ignore each other and go about doing what they believe needs doing. Occasionally, we see a healthy debate between communities within the larger platform community – and that’s good, as that’s how open communities evolve.

The whole schedule looks great, but I’m especially looking forward to:

Saturday:

• Building a Scalable WordPress at News Corp UK (Luke Wheatle, Sophie Plimbley)
• A User-First Approach to Metadata (10up‘s own Helen Hou-Sandí)
• <picture> and Friends: HTML Responsive Images (Bruce Lawson)
• From Web Address to Web Page – the Humble URL in WordPress (Simon Wheatley)

Sunday:

• Think Big, Grow Fast. Breaking Into The Enterprise Market (Fabio Torlini)
• User Experience in WordPress (Sara Cannon)
• Hiring Employee Number One: From Freelancer to Agency (Brad Williams)
• How We Built a Market-Leading WordPress Agency; And Why We Walked Away (Simon Dickson)

I’ll be interested to see how Fabio Torlini’s talk overlaps with / compares to the talk I recently gave at Prestige in Las Vegas on the Enterprise Disconnect in the WordPress community.

Will you be there as well? Please do say hello.

We do expect to continue to grow 10up’s presence in the EU and in the UK in particular, so let me know if you’d be interested in talking to us about joining the team.

Folks interested in WordPress and Open Source licensing should really start following  WP and Legal Stuff, a new blog from Richard Best, a “dual qualified” lawyer (New Zealand, England & Wales) focused on “IP/IT/technology law and public law.”

Happy to see a number of really excellent posts already on the site, including:

• Understanding the GPL licensing of WordPress (with an excellent FAQ style section at the end which should be required reading for anyone starting to develop and release themes/plugins for the platform)
• Using the WordPress trademarks for your business, product or service (I’ll even forgive the lack of the Oxford comma, as he used and correctly attributed one of my cc-licensed photos)
• WordPress themes, the GPL and the conundrum of derivative works

Best does a great job summarizing complex legal matters and debates and providing what (to me at least) feels like a reasonable summary.  Of course, as his disclaimer tells us:

The material on this site is for general informational purposes only. It does not take into account your specific requirements or circumstances, does not constitute legal or other advice to you or anyone else and you rely on it at your own risk.

So it was only this morning that I listened to an episode of The Dirt from back in December 2014: Open Source pt. 2: Licensing Matters with Gabe Levine.  This was the 2nd in a (so far) three part series on Open Source from a podcast I usually really enjoy, put out by an agency (Fresh Tilled Soil) for whom I have tremendous respect. It was on a topic (open source licenses) about which I think most web designers, front-end developers, and web developers need significantly better education and understanding. It included as a guest a lawyer (Gabe Levine) whose twitter bio describes him as a “New Media Lawyer Extraordinaire” and who was described by The Dirt post as a “super lawyer.”

That’s why I was so disappointed.

Beyond muttering to myself on my morning walk, I just have to respond to some of the major issues I had with the podcast. (No comments allowed on the blog where the podcast is posted, so I’ll write here and tweet to the podcast).

1. The obligations of the GPL are triggered by distribution

The group discussed the differences between different licenses and the fact that GitHub does not require a license be selected for a project, but does now encourage it (see Github on licensing).

What no one mentioned was the helpful choosealicense.com site GitHub launched to help people choose, which does a very simple and clear job explaining the differences between popular licenses. (Simplified, but generally accurate).

The discussion turned to the GPL and its “copyleft” cause, which says that if you distribute changes you make to a project licensed under the GPL, or if you distribute a project that is a derivative of a project licensed under the GPL, you must make your software available (to those to whom you distribute it) under the GPL as well. This means you pass on the same four freedoms you enjoyed from the upstream project upon which you are  building.

One of the podcast hosts (Tim?) asked, in essence, what if I build a site on a GPL platform like Drupal? Am I obligated to share all of my code under the GPL?  Gabe answered no, but implied that was because the code Tim would have written in that case would not be considered a derivative. No one even mentioned the concept of distribution at all. 

The reality is, you can take a project licensed under the GPL, modify it, make derivatives of it, make it run 300% faster, add features, extend the core, and run it on your own servers as often as you wish. As long as you are not distributing the code to anyone (offering it for download or shipping CDs), distribution has not been triggered.

Google reportedly makes many modifications to linux distributions to improve efficiency in their data centers – and is under no obligation to share that back.

Acquia had for some time has a project called Drupal Gardens, which enables users to set up free Drupal sites in a SaaS model – like WordPress.com – and was under no obligation to open source that project, though it was quite clearly derivative of Drupal.

Automattic, in addition to WordPress.com, offers WordPress.com VIP hosting, and has created various bits of software to make that platform run efficiently – as have many other managed WordPress hosts – and they are under no obligation to release those platforms.

For companies who are building their website on a platform that is GPL licensed, they are not distributing that software. It is very common, in building a WordPress powered site, to develop custom plugins or complex themes, which are at least partially “derivative” of the core software. (Some parts of themes might not be derivative, but let’s accept for the sake of argument the generally accepted thinking that the php code in themes and plugins is derivative). Those companies are not obligated to release those plugins or distribute them at all. The issue is only when they do decide to distribute them – in which case they need to make them available to the distributees under the GPL.

To repeat: if you are not distributing your modifications/derivative works, you need not share them with anyone, including the source project. 

If you are building software you intend to distribute, and don’t wish to distribute under the GPL, you should not build on GPL software.

If you are building software you do not intend to distribute, you need not worry about GPL infection. This is why even Microsoft (as strongly anti-GPL as any company I can think of) has no problem hosting WordPress powered sites.

2. The GPL is used by many of the largest and most successful projects

Ok, so maybe in this case I’m being overly sensitive.

The whole discussion was presented in such a way that made GPL licensed software sound like it was only for fringe projects, or was unpopular.

Let’s not forget that all of the most successful open source content management platforms are licensed under the GPL: WordPress, Drupal, Joomla, and so on.

Let’s not forget that Linux itself is licensed under the GPL – and is undoubtedly the most common server operating system on the web.

Let’s not forget that Git is licensed under the GPL (and yet this doesn’t prevent GitHub from being a hosted service based on Git).

I’m not arguing that the MIT license is a bad license, or that people who choose “permissive” licenses over “copyleft” licenses are doing it wrong – but to suggest that the GPL is some kind of fringe case is simply wrong.

3. Creative Commons did not inspire the software licenses; it was inspired by them

Later the conversation turned to Creative Commons, and the license variations Creative Commons offers, which are designed (thus the “Creative” in the name) to allow creators of creative works (photography, art, illustration, music, writing, etc) to define the ways in which they want their work shared. (Or the conditions under which such sharing is explicitly allowed by the copyright owner).

Gabe (I believe – I could have the voices assigned to the wrong speakers) suggests that perhaps Creative Commons was first, and inspired the software licenses.

That’s like suggesting that perhaps horse-drawn carriages were inspired by the early automotive marketing industry.

Creative Commons was formed in 2001, and released their first license in 2002. The inspiration flowed exactly the other way: “Creative Commons developed its licenses – inspired in part by the . . . GPL.”

The Free Software Foundation was organized as a 501(c)(3) in 1985, and the notion of using the license the FSF had created as a General Public License appears in 1988 or 1989.  The GPL v2 was released in 1991.

4. Dual licensing is common

The notion of dual licensing also came up near the end of the discussion, and it seemed a wholly novel idea – that a piece of software would be available under multiple licenses.

This is not uncommon. MySQL itself has long been available via GPL or via a commercial license which enabled you to build it into products that would be distributed without triggering the GPL distribution clause.

Even commercial software is regularly dual licensed. You can get Microsoft Word or Adobe Photoshop or Apple Keynote retail as an individual, or via an OEM license, or as a corporate subscriber to a corporate license, or as a student under a student license, etc. Each of these may be the exact same set of bytes but made available under different license regimes and restrictions.

There are complexities for open source projects with respect to dual licensing. The copyright holder needs to agree to licensing changes – so in the absence of a contributor agreement or copyright assignment, an open source project that has taken a number of contributions from many people may be unable to change the license retroactively.

Licensing Matters

Apologies in advance if this whole post feels like a rant. I know the folks at The Dirt are not intending to spread misinformation or scare people about working with open source software, but I think it is really critical that people understand what the GPL does and does not require.

I am not a lawyer, and don’t even play one on the internet. But there are many great resources that can help you understand what the licenses do and do not mean. Here are just a few:

• Free Software Foundation – Licensing
• Open Source Initiative  – Open Source Licenses
• ChooseALicense.com
• Creative Commons 
• Which Open Source Software License Should I Use?
• Comparison of Free and Open Source Software Licenses (wikipedia)

For key projects I’ve worked with, here are there pages on the concept:

• WordPress: License, Philosophy (see the “Bill of Rights” section of that page).
• Drupal: Licensing FAQ

Unfortunately, just like Official.fm, Mixcloud doesn’t provide a “true” RSS feed with enclosures. So I had to hack together another script to feed my podcatcher with the full quality downloads.

When I first started searching, I found a few hopeful options:

• Meloncholy’s Mixcloud RSS Converter – which you can see in action at http://bits.meloncholy.com/mixcloud-rss. Unfortunately what this does is use the Oembed functionality  to create a real RSS feed but one where each episode is embedded, rather than in the RSS feed as an enclosure. Good for streaming, not for playing when you’re offline.
• Georgi Pavlov’s Mixcloud RSS feed generator – this one does work well, and allows you to choose between m4a and mp3, as well as how many episodes back to grab. This worked pretty effectively, but I didn’t like that I was consuming someone else’s resources and wanted one I could run on my own server. (One thing his does which mine does not yet is pull each episode’s description).
• Many pointers to offliberty.com and numerous similar sites, which can translate and provide download links for individual episodes – but again I didn’t want to be dependent on them. (See also Mixcloud Downloader,  MixCloud Downloader, and Mixcloud Downloader – the last one a chrome extension).
• A couple of sites which pointed out how to find the url of the m4a file – using Chrome inspector, net-internals, or similar mechanisms.

Ultimately I ended up making my own: Mixcloud RSS download

It’s fairly simple to configure. I use a cronjob to refresh it every 24 hrs, then point my podcatcher at the saved output. (You can see the results here or put http://johneckman.com/mc/feed.xml in your podcatcher to test).

Note downloads are limited on the mixcloud side – so a 2 hr podcast (like The Waiting Room) will actually take 2 hrs to download. I suppose a future version might do the downloads server-to-server and then cache locally the most recent X episodes.

Let me know if you try it with other podcasts and how it works (or doesn’t, of course) using the github issues queue.

It’s a great video to begin the year with, tracing the evolution of the web design community from the earliest days, though the founding and evolution of Zeldman’s many communities/activities, including:

• A List Apart – which started as a mailing list and morphed into an early web magazine, but has had an amazingly consistent, quality, curated and editorially managed voice for the best in web design and front-end engineering. It brought together the ethos of the early web – what you know, you share with others – with an approach that essentially kept out the flame wars, bullying, and noise that were so prevalent elsewhere. I think of it to this day as the first real professional community I wanted to be a part of – and it remains one of the best places to find the latest thinking about real world challenges for web professionals.
• The Web Standards Project – the banner carrier for web standards during the years when people were either completely ignorant of them or explicitly hostile. The fact that you almost never see a “This site best viewed in Internet Explorer” link as you browse is in large part due to the efforts of this group, which had to inform and educate browser-makers and web designers/developers at the same time.
• A Book Apart – continuing in the same direction of a curated voice for web professionals who cared about the craft and were serious about design and technology, this series of books has consistently identified, amplified, and nurtured the best voices: Ethan Marcotte on Responsive Web Design, Karen McGrane on Content Strategy for Mobile, and Luke Wroblewski on Mobile First just to name three of the giants in a series of great books. (If I made gift lists for recent grads / young professionals in the web industry, the complete A Book Apart Library would be at the top of that list).
• An Event Apart – curated, single-track conference on the (always emergent) best-practices and key philosophies behind building web sites right. I’ll confess here I’ve never made it to one – but have sent colleagues and watched innumerable talks either recorded at An Event Apart of premiered there and later given in other venues. If a speaker you have a chance to see somewhere has been a speaker on the Event Apart circuit, don’t miss them.

If the video sometimes comes across as a lifetime achievement award montage – which it did to me – that shouldn’t be taken to mean Zeldman’s not still active, in many of the above businesses as well as Happy Cog and teaching at the School of Visual Arts in NYC.

It’s a fantastic video to start the new year with as it reminds both of how far we have come and also of how dynamic and emergent the whole industry remains. (If first few “testimonial” bits bother you skip forward to 1:45 or so where the real story starts).

Thanks to the folks at Urchin studios for producing this video in celebration of 30 years of the Free Software Foundation:

Join the Free Software Foundation today.

View my full report or make your own.

If you’ve not encountered the fox and the hedgehog (via Jim Collins, via Nate Silver, or elsewhere), it’s a distinction made famous by Isiah Berlin’s 1953 book on Tolstoy, taking off from a fragment of Archilochus:

the fox knows many things, but the hedgehog knows one big thing

Berlin uses this notion to divide historic writers and thinkers into two camps: those who focus on going deep in analysis of one area of expertise versus those who synthesize and compare across many areas, disciplines, and approaches.

It struck me that this pair of characterizations worked well to describe a recent BostonJS meetup, which featured Mat Marquis (@wilto) (hedgehog) and Ethan Marcotte (@beep) (fox).

Mat dove deep into the past, present, and future of responsive images.

(This video is not from BostonJS, but looks to be quite similar.)

Mat’s singular focus, in identifying the problem of responsive images (the lack of a clear, standards based way to send only the correct image size and pixel density for a responsive design), collaborating with others on solutions to the problem, and getting those solutions actually adopted as part of a W3C standard, is amazing and inspiring.

Web design and development is still an industry in which a set of designers/developers concerned about the real world impact and global accessibility of the web can get involved and actually change the rules on the field of play. Check out the Responsive Images Community Group for more.

Ethan’s talk was focused more broadly on what he called “Laziness in the Time of Responsive Design.”

This video’s also not from BostonJS, but it is a very similar (slightly earlier) version of the talk from that night, with many of the same examples.

Ethan started with the story of the Pando forest in Utah, which isn’t so much a forest as a tree: one “clonal colony” covering 140 acres. Besides being the world’s oldest living organism and the world’s heaviest living organism, it’s also a great metaphor for the difficulties front-end developers and designers face in trying to keep in mind both the forest and the trees of responsive design and development.

Ethan basically argued that sometimes the best path to achieving responsiveness is letting go: leveraging simple structures of HTML and CSS, in support of design systems, in place of complex grid frameworks and javascript interactions. Of course what Ethan calls “laziness” I’d call clever restraint. It does, in the end, require less code – and in the end the code is specifying less in order to achieve the desired result – but that’s hardly laziness. You’ve got to have a really solid understanding of the underlying behaviors of HTML/CSS before you can even begin to think about design systems.

In the end, the point isn’t to focus on whether any individual is a hedgehog or a fox, but to recognize the value (and necessity) of both ways of thinking.

We need folks like Mat Marquis pushing hard over months and even years to get the standards and specifications in the right place, just as we need people like Ethan Marcotte reminding us to not lose sight of the overall goal and the philosophy behind the page design, drawing on broader disciplines and histories of architecture and design.

In my own career, I’ve certainly played more fox than hedgehog, jumping from Academia (and an interdisciplinary PhD that never could quite settle on a single genre/medium/discipline) to web development, and within web development having been a front-end developer, user experience designer, project manager, technical architect, managing director, and CEO. But it’s only when I narrowed my focus – first to the open source CMS space and most recently to WordPress – that I really found the value of knowing one thing well.

Menu items which link to pages reflect not only the right language for the menu text, but also automagically link to the correct url for the current language. The challenge I found was with custom menu items. They show the correct text for the menu item by language, but because of the way WordPress handles the “url” of the custom menu item, you can’t use multiple languages in that field.

The right way to fix this, I suppose, would be a custom plugin which extends the custom menu item to allow multiple URLs by language, and then updates the admin interface to show the appropriate URL field for the current language, just as qTranslate does to show the appropriate menu text for the current language (inside the dashboard & when output).

But I didn’t have time for that.

The goal was to add a link in primary navigation menu to another project of Food Empowerment Project, VeganMexicanFood.com. That site has a different url for English and Spanish, but is an external link.

The simple answer I found was to use the wp_nav_menu_objects filter:

function vmf_menu_links($items, $args) {
     if(qtrans_getlanguage() == 'en') {
          return $items;
     }
     foreach ($items as $item) {
          if ($item->ID == '512') {
               $item->url = 'http://www.veganmexicanfood.com/index_es.htm';
          }
     }
     return $items;
}
add_filter('wp_nav_menu_objects', 'vmf_menu_links', 10, 2);

This filter first checks to see if we’re in English – if we are, it just returns the items unchanged. If we aren’t, that means we’re in Spanish (we only have 2 languages). In that case, loop through the items and when you find the item with ID 512 (the link to Vegan Mexican Food), change the url of that item.

Of course this hack hardcodes the ID of the menu item targeted, as well as the url to use. But for a quick hack it works well, and since the site is heavily cached I wasn’t too worried about performance impact. (You can find the ID of the item easily by looking at the CSS where it is output in the menu).

It could be extended as a switch statement to look for multiple languages and substitute appropriate urls.

This week’s Creative Mornings Boston was held at Brooklyn Boulders in Somerville.

Creative Mornings continues to surprise and delight as an event. I think this is the first time I had to sign a safety waiver just to hear a short talk about business.  The morning also starting with the crew from the Blackout Step Team from Tufts, performing an impressive routine (especially for 9am!).

Then Nataly Kogan from Happier gave a quick but inspiring talk about taking chances – sharing moments from her own life (emigrating from the Soviet Union to Detroit, betting on Constant Contact as a junior partner at a venture capital firm, and spending 2 hours talking happiness research with a cynical audience member who turned out to be a NY Times reporter.

Kogan’s great because she’s no pollyanna – she takes the science of happiness seriously, and recognizes the need to take creative chances, but also understands that you can’t know in advance which chances will work out and which will fail.

It isn’t about taking chances and getting lucky – but it is about that moment when preparedness meets opportunity. If you’re not taking chances frequently enough, you’re minimizing the number of potential opportunities.

What chances are you taking this week that could become big opportunities?

In trying to cram a longer discussion down into a lightning talk, of course I left out much of what I’d hoped to get to.

A few positive examples of conferences that bring together multiple platforms:

• CMS Expo in Evanston Illinois, which brings together open source and proprietary systems. (Recently changed to an every other year schedule, so the next will be May 2015).
• New England Regional Developer Summit, which grew out of (largely) the Western Mass Drupal Camp

Some of the podcasts which I listen to regularly for good perspective (in addition to my WordPress focused ones of course):

• Karen McGrane and Ethan Marcotte‘s Responsive Web Design podcast. Two of the smartest folks thinking about a multi-device world doing a podcast where they interview real practitioners on the challenges they faced? Yes please.
• Jeff Eaton‘s Insert Content Here. Jeff’s a Lullabot, with great depth in the Drupal community but also a broad interest in and knowledge of content strategy. (“Cheeky conversations about content strategy, riveting tales of projects gone off-the-rails, and reflections on life in the trenches of digital publishing”)
• CMS Chronicles – found this when they interviewed 10up’s Rachel Baker about WordPress, so only started listening more recently, but they’ve had episodes on Statamic, Expression Engine, CraftCMS, Drupal, and Jekyll.
• The Web Ahead – Jen Simmons‘ podcast on the 5by5 network, including an occasional series on “The Web Behind” tracing the history of how we got here. Smart guests, long conversations about web design and development broadly.
• The Big Web Show – Zeldman‘s show which started on 5by5.ty, then was on mule radio, and now is back with 5by5?. Whatever, just find the podcast feed and subscribe.
• CMS Myth – blog covering the CMS space generally, of which I’m a proud emeritus contributor. Does an excellent job of putting the content and the people first, and not letting the platforms and vendors get away with running the show.

It’s also a great idea to explore other conferences and local conversations and meetups, including:

• Confab Events – Confab Central, Confab Higher Education (I’ll be speaking there this month), Confab Government, and Confab Intensive. Kristina Halvorson has assembled an amazing team that puts on really high quality events focused on content strategy
• Creative Mornings – my favorite time for events is actually before work, rather than after. Creative mornings happen in many different cities, with a focus on design and innovation: “a breakfast lecture series for the creative community.” Lots of their talks are recorded and can be watched after the fact online, but get up on time and go see them in person.
• Refresh Boston – check out all the Refreshing Cities
• Build Guild – “a friendly, monthly gathering for all web folks that enjoy chatting over drinks. High-fives encouraged. Mustaches optional.” Many local options in smaller cities / secondary markets, including Salem MA where it all began.
• BarCamp Boston, and BarCamps in many other cities –

Where do you find your best ideas come from, outside the community where you spend the majority of your time?

I really enjoyed the conference last year: impressive keynotes; focused, carefully curated set of breakout talks; and a great crowd of motivated, inspired folks fighting the good fight to improve digital experiences for students, prospects, alumni, and faculty across the range of higher education.

My talk this year is “Engineering Influence: Talking to Developers about Content.” I’ve long said that Content Strategy folks need to exert more influence on technology and can’t just “stay out of the conversation” when it turns technical.

How do content people (those who come to the conversation fundamentally concerned with content production, quality, clarity, and experience) talk effectively with technical people (those who come to the conversation fundamentally concerned with a technical system perspective – what to build, maintain, or customize)?

This isn’t to say content strategy folks should try to take over technical architecture, or to give technical folks a pass on their need to care about content and user experience – just to give some tools / techniques for making that conversation more effective.

The camp is taking a different approach this year, mixing sets of lightning talks in between more traditional conference sessions – see the full schedule.  My talk will be in the set of lightning talks titled “WordPress in Context”  and is called “Learning from the other 78%.”

The basic idea is to look more outside the community of believers and see what we can learn from those we rarely talk to – the folks who aren’t at WordCamps or meetups because they aren’t (yet?) users.

Case in point this very weekend is both IndieWebCamp Cambridge and BarCampBoston 9.

IndieWebCamps come out of the IndieWeb movement, a group of people focused on an alternative to what they describe as the ‘corporate web.’ That is expressed via three principles:

• Your content is yours. (It doesn’t belong to a privately owned social network whose terms and services give it de facto ownership if not de jure)
• You are better connected. (Posting on your own domain, literally, so that external services all point back to your own site, rather than everything about you connecting to a site which again is owned by someone else)
• You are in control. (Simple, restful, human readable urls to the things you want to post in the format you want, that live forever because you control every part of the domain).

There are many other principles and a number of projects underway which align to these principles.

Personally, I’m really interested in “Publish on your Own Site, Syndicate Elsewhere” (POSSE) and how WordPress can be leveraged in support of the principle of an independent web.

BarCampBoston 9 is a much broader event:

BarCamp is Boston’s geek unconference, organized on the fly by attendees, for attendees.

The event is free and open to anyone, but you don’t just attend a BarCamp — you can host or participate in discussions, demo your projects, and meet other techie, geeky people like you.

This year we’ll be at Microsoft’s New England R&D Center, October 11th & 12th.

BarCamp Boston topics include: technology, development, food-science, startups, sci-fi, 3d printing, social media, gadgets, communities, design, hardware hacking, UI & UX, entrepreneurship, AJAX, open source software, robotics, art, mobile computing, bioinformatics, RSS, social software, programming languages, the future of technology, and much, much more!

I’ve contributed to the BarCampBoston organizing team and volunteered, though this year that’s mostly been the “show up for pizza at an organizer’s meetup” style of helping. ;)

It was in preparation for BarCampBoston (the first!) that I originally launched this blog, and at BarCampBoston 3 (in 2008) where I have some my earliest talks about WordPress.

Has anyone seen an open source cloning program I could install tonight so I can go to both tomorrow?

Facebook has changed the way the API is versioned, and new apps made in Facebook are no longer able to call the v1 of the API, use FQL, or other things I was depending on.

So, I’m releasing today new versions of both.

For WPBook Lite, which is the one you have to use if your blog is not accessible via HTTPS, the new version will be 1.6.1.

For WPBook, which enables the Facebook Canvas page in addition to the features of WPBook, the new version will be 2.7

I’ve also tested both with WordPress 4.0 and added plugin icons that WordPress now supports.

As always, please use the WordPress.org support forums for support issues, not comments threads here. Thanks.

First WordCamp New York, a talk on Modernism Post-Modernism, and Responsive Web Design:

“These fragments I have shored against my ruins”: Modernism, Post-Modernism, and Responsive Web Design from 10up

Then, from earlier this morning at WordCamp Maine, a talk on Delivering the News on WordPress with Matt Fulton from MaineToday Media:

delivering-the-news-on-wordpress from 10up

Finally, my keynote from WordCamp Maine after lunch, on the power of free software and community:

building-communities-building-software from 10up

• D4D (Design 4 Drupal) Boston 2014 will be August 1st-3rd at MIT
• WordCamp NYC 2014 will be August 2nd and 3rd at the Marriott Brooklyn Bridge
• WordCamp Maine 2014 will be August 15th & 16th at the Maine College of Art, with a contributor day on the 17th at Casco Bay Tech Hub (Portland, ME area).
• WordCamp Boston 2014 will be August 23rd at MIT, with a contributor day August 24th at Workbar Cambridge.

September is not looking to a quiet month either:

• Just missing the “August is Camp month” memo is the New England Regional Developers’ New England Regional Digital Summit (a multi-platform / multi-community event) which is Sept. 12th-14th in Amherst.
• WordCamp Providence is scheduled for Sept. 26th-26th

So much for taking the late summer easy . . .

In the fall, New England Drupal Camp (NEWD Camp) will be November 1st also in Providence, RI.

Video:

Slides:

What can the WordPress community learn from the talk?

Dries’ general perspective is clear and well articulated:

• Experience is the key. While it isn’t always clear from the experience of using Drupal (sorry, couldn’t resist), Dries and the core team have long focused on improving the usability of Drupal for content authors and site managers. Using the evolution of the “photographic apparatus” as an example, Dries traces how each stage in the evolution simplified steps to the point of removing them from consideration. Like design, technology is at its best when it is invisible, improving the users’ capabilities without adding complexity to the experience.
• Technology innovations enable experience. As the process of taking, storing, and sharing photos got simpler for the end user, it actually got more complex on the “back end.” Compare the basic chemical processes of early photography with the hardware and software behind a modern camera phone: the experience for the end user gets more simple while the technologies assembled to create that experience get more complex.
• We’re heading from the assembled web into the experience web. Open source components and an assembly methodology have dramatically improved the capabilities of developers, enabling us to bring together many existing, functional components into a larger experience. The experience web leverages semantic markup and multiple devices to bring sophisticated capabilities to users while at the same time simplifying their experience.
• The open web is closing up. Dries argues that as the big players get bigger, it gets harder and harder to compete as an independent site. The challenge is these experiences can often be better for the consumer in terms of convenience and ease of use, but they ultimately represent a re-intermediation, inserting the search engine or social platform in between you and the content (brands, products, people) with which you want to interact.

Dries’ focus, of course, is on what the role of Drupal will be in driving forward the “Experience Web”: providing multi-channel semantic markup in multiple formats to provide next-generation search and e-commerce experiences. (The second 30 minutes of the talk is more focused in on changes to the core architecture in Drupal 8).

What does this mean for WordPress?

I’d love to hear your thoughts in the comments, but here’s a few I’d start with:

• WordPress is even more well positioned to create an ideal authoring experience, letting users easily create complex structured content – and to expose that content in multiple formats and multiple contexts. While the majority of users of the platform may be only looking for a web site that renders pages and posts as html, the combination of custom post types, custom taxonomies, and custom metadata (along with plugins like the JSON-REST API) enables WordPress to power the same kind of rich, extended, experience web style applications Dries describes for Drupal.
• The WordPress community can’t rest on its laurels with respect to ease of use. Check slide 162, where Dries claims “effortless authoring” as one of the features of D8 (specifically calling out in-place editing, responsive back-end, and a redesigned content creation page). WordPress has to continue to evolve what ease of use means, fighting hard to maintain the core simplicity (“smart defaults over choices” and so on) while adding the power of complex content types, taxonomy metadata, incorporating the JSON-REST API, and so on.
• Drupal has made a deliberate shift from a “not invented here” attitude to a “proudly found elsewhere” attitude, incorporating significant elements of the Symfony framework as well as Twig as a templating language. While I don’t believe the WordPress community suffers as much from “not invented here” as Drupal did historically, I would love to see continued focus on what we can learn from other communities. In some cases that will mean actually being able to leverage code from other communities, in other cases it will mean adapting patterns and approaches, but modifying them to be appropriate to the culture and user experience of WordPress.
• Drupal’s “epochal” release strategy – where 8.0 is a fundamentally different release than any 7.x, which is a fundamentally different experience than 6.x, and so on, has its advantages and disadvantages. The major disadvantage is that those primary releases take multiple years to arrive, and require hugely substantial rewrites of core functionality, contributed modules, and even sites built on the platform. (It’s not uncommon, in my experience, for people to spend the better part of a year on a major version upgrade of their site on Drupal). The advantage is a chance to tell the story of progress, to very visibly remove legacy experiences and code, and to claim the arrival of a new era. I often talk to people who say “I used WordPress once; it’s too simple for my needs,” only to discover the last time they looked at WordPress was in 2.5 or 2.7 (which is to say, pre-multisite merge, pre-custom post types, and so on). There’s no epoch to measure, to say WordPress 3.x is fundamentally a different platform then 2.x, or WordPress 4.x will be the culmination of 3+ years work by the community to rewrite the platform from the ground up. I’m not suggesting we should shift to this model – incremental change is less disruptive to the site builder and the end user, not to mention to plugin and theme developers or those building products on top of the platform – but incremental change can be more difficult to notice/sense. We need to do a better job articulating the changes that have come and the power the platform has (and will continue to have) while not losing the simplicity and elegance of the user experience.
• Drupal’s going after the enterprise in a major way. Large brands, complex IT infrastructures, and large teams of developers line up well to large scale Drupal development. Acquia’s sales team is part of this effort, but I don’t think it is a case of Acquia running in a direction other than that of the community – I think Acquia is working with the community as it heads that direction. Of course there are those in the community who don’t welcome these changes – see Backdrop for one visible example – but the Drupal community on the whole is making a deliberate and sustained effort to become “the enterprise platform.” I don’t ever want to see WordPress lose our focus on the end user, but I think we definitely can do a better job telling the story of the enterprise WordPress user. (WordPress.com VIP and the Big Media and Enterprise WordPress meetups are the start of this process, but not the end).
• WordPress can help retain the Open Web. I was disheartened to hear Dries say basically we can’t stop the open web from closing. I don’t disagree with him about the increasing dominance of a few key players in our daily lives online, but I think the antidote to that is the continued presence of many smaller players, enabled by technologies like WordPress. The IndieWebCamp movement, BarCamp, and WordCamp all suggest to me a strong and vibrant future for the truly open web. WordPress’ core mission, to democratize publishing, can and should continue to be a strong antidote to the evolving closed, monolithic, corporate web.

Of course there’s also the requisite “WordPress can’t come close to doing this” and “it’s miles and miles away from doing this” at 37:20 into the talk. It isn’t really clear what it is Dries is saying WordPress can’t do – output semantic marked up content? Provide a REST api? Enable complex content types? Serve as a headless content repository to be consumed by other frameworks? I don’t see anything in his description that can’t be done with WordPress, albeit with leverage of plugins and custom code. (Largely this is due to WordPress staying true to a “small core” approach, keeping more of the needs of smaller portions of the audience in the plugin space rather than moving them all into core).

What’s your take?

What does the direction of Drupal as laid out by the project’s founder and lead suggest about the future for WordPress?

How can we continue to take on the use cases and needs of large teams of developers and enterprises, without making it too difficult for smaller companies to leverage the platform, and while preserving the image of WordPress as an attractive platform for independent developers to learn?