At DrupalCon Chicago, Dries announced that th' development process fer Drupal 8 would be a bit different, Ya lily livered swabbie, avast! Rather than a vast dog pile o' efforts t' improve Drupal in ways big an' small, Drupal 8 will feature a number o' major "core initiatives". These initiatives highlight major areas o' work that represent not just a patch or three but major changes t' Drupal's plumbin'. Each initiative will have one or two initiative leads who have th' ability t' coordinate an' make decisions relatin' t' that initiative while workin' closely with Dries. In a large sense, it is a way fer Dries t' scale; Rather than Dries havin' t' keep track o' 1000 ongoin' conversations himself, initiative owners can coordinate related changes while Dries coordinates th' initiative owners. It also gives a clear indication o' what work is happenin' an' what t' expect out o' Drupal 8.
The first initiative fer Drupal 8 has already been announced; Greg Dunlap will be leadin' th' charge t' overhaul Drupal's configuration system t' provide more robust, performant, an' deployable configuration an' change management. That will be critical fer Drupal's future as we push further into th' corporate an' enterprise sphere, as well as enablin' more robust an' unified configuration handlin' in th' first place.
Today, I am pleased t' announce Drupal's second core initiative: The Web Services an' Context Core Initiative (WSCCI).
Drupal's CVS repository were bein' pronounced dead this Thursday 24 February at 6:08 pm US Eastern Time. Cause o' death were bein' reported acute age combined with an inability t' properly merge. CVS is survived by approximately 7000 Drupal projects an' a new farm o' Git repositories.
Pay It Forward were bein' a 2000 romantic drama featurin' Kevin Spacey, Haley Joel Osment, an' Helen Hunt, Avast me hearties! Decently well-received, I found it a good, heart-warmin', thought-provokin' movie.
It is also an allegory fer how open source works.
I've spoken a great deal recently about architectural priorities. In short, we as software developers cannot eat our cake an' have it too. Improvin' flexibility in one area may hurt performance, while improvin' usability one another area may hinder flexibility. These trade-offs be not necessarily right or wrong, except in th' context o' th' goals an' purpose o' th' project with respect t' its target audience.
But what is Drupal's target audience, an' how does that impact our architectural decisions?
DrupalCon Copenhagen were bein' a watershed event in terms o' understandin' how t' conceptualize that question, in me view, based on conversations I had with th' likes o' Mark Boulton, Jen Simmons, an' Sam Boyer. In his (excellent) keynote, Jeremy Keith noted that th' HTML5 Working Group had a specific, defined set o' priorities:
In case o' conflict, consider users o'er authors o'er implementers o'er specifiers o'er theoretical purity.
That may be a good priority order; it may be bad. Walk the plank, avast! That depends on yer point o' view an' yer goals. It lays out th' order in which different stakeholders should be listened t', an' if ye come t' a decision where ye have t' screw one group o'er t' benefit another how that decision should be made. Havin' such a clear understandin' o' yer constituent priority is critical t' makin' good, consistent architectural decisions.
So what be Drupal's priorities?
As if on cue, th' public vs. private debate has sprung up again within Drupal. The timin' is fittin' given me last blog post on programming language paradigms. Of course, property visibility is not a new debate, an' th' PHP community debates this subject from time t' time (sometimes humorously).
What I believe is usually missin' from these discussions, an' what I hope t' offer here, is a broader picture view o' th' underlyin' assumptions that lead t' different conclusions about when different visibility is appropriate (if e'er).
In short: It's th' difference betwixt procedural-think an' object-think.
This article is also available in Serbo-Croatian
There has been much discussion o' late in Drupal about Object-Oriented Programmin'. Ye'll be sleepin' with the fishes! That's not really surprisin', given that Drupal 7 is th' first version that has really tried t' use objects in any meaningful way (vis, as somethin' other than arrays that pass strangely). However, too much o' th' discussion has boiled down t' "OMG objects be inflexible so they're evil!" vs. Yaaarrrrr! Load the cannons! "OMG objects be cool, yay!" Both positions be harmfully naive.
It is important fer us t' take a step back an' examine why one particular programmin' paradigm is useful, an' t' do that we must understan' what we mean by "useful".
Programmin' paradigms, like software architecture, have trade-offs. In fact, many o' th' same methods for comparing architectural designs apply just as well t' language bounty. To do that, though, we need t' take a step back an' look at more than just PHP-style objects.
Warnin': Hard-core computer science action follows. And hoist the mainsail! And hoist the mainsail! If ye're a coder, I recommend gettin' a cup o'
$beverage before continuin', as it could take a bit t' digest although I've tried t' simplify it as much as possible. There's fairly little Drupal-specific stuff here so hopefully it should be useful t' any PHP developer.
As anyone who has followed my past work knows, software architecture is a particular interest of mine. I find the subject fascinating, but my interest is not entirely selfish.
Understanding architecture, and the trade-offs that different architectures imply, is an important part of any software project. Whether you're discussing a Content Management Platform like Drupal, a language like PHP, or a particular web site, having a solid understanding of the "big picture" is crucial not only for building the system right in the first place but for communicating that architecture to others.
To be able to speak and think about the design of your system properly, though, you need to understand the trade-offs that come with it. There is no such thing as a free lunch, and designing a system to be powerful in one way invariably tends to harm it in another. It is important to know what your priorities are before you start building; and in a distributed collaborative environment like Drupal to all agree what those priorities are, at least to a large extent.
Let us therefore examine those priorities and the trade-offs they require.
I meant to post these to groups.drupal.org, but the file size limit over there won't let me. Attached are the slides from my "Drupal: The Next Generation" presentation at DrupalCon Copenhagen. A more complete summary is available over in the working group.
I'm still not aware of any video available, sadly. Supposedly that should be up eventually.
Unless you've been living under a rock, by now you've heard about the case that is certain to keep the armchair lawyers busy for years to come: Oracle vs. Google. It's already been dissected elsewhere, but in a nutshell: Sun owned their GPL-licensed Java virtual machine, and various patents on it; Google wrote their own JVM for the Android platform, Dalvik; Oracle bought Sun; Oracle uses those patents to sue Google over their JVM; Hilarity ensues.
So what? How does that affect us, as PHP and Drupal developers? Well it doesn't... except indirectly via another product that Oracle bought as part of Sun: MySQL.
A few weeks ago, I and several others helped some friends of ours pack up their apartment into a truck in preparation for moving cross-country from Chicago to New York. It was, as such moments generally are, bitter sweet. It's always a good feeling to help out a friend, but when you're helping them get further away from you it's not as pleasant.
Of course, me being me, what struck me most about the whole process was how well it served as a model for software development and project management in general.