Drupal at a Crossroads

Huge Changes

In code and process

Gigantic Dev Cycle

4 years!

"When it's Ready"

Led to speculation, worry

Community Shakeup

Long time devs left or reduced involvement

Forked!

Not the first, but highest profile

But let me tell you a different story...

Let's go back to 2012

Drupal 8 had just gotten started

Drupal 7 is weird

Anachronisms

Straight functions (mostly)

PHP4's OOP was odd & incomplete

Hooks are API Go-Fish

Arrays of Doom!

Undocumentable Monstrosities

Lack of a language feature patched with human effort.

Tech Wasn't our Biggest Problem

We liked our own code...

...a little too much.

Not-Invented-Here (NIH)

Prefer in-community solutions despite costs.

PHP 4 Didn't Help

Dependencies were copy-paste.

Required manual effort to build, update.

NIH has a social cost

Sunk-cost Fallacy

"Point of no return" thinking

Sunk Costs in Software

Makes replacement of large subsystems impossible

Sunk Costs in Drupal 7

PHPTemplate vs. Smarty, etc.

Simpletest vs. PHPUnit

Many others...

NIH made Drupal Insular

We rarely worked "upstream".

I <3 Drupal

Just don't tell me how you work.

Four Years Later...

What Makes Drupal 8

"Community Ready"?

Technology is enabler for people!

So, who did we enable with Drupal 8?

Drupal Developers' Delight

Patching and Hacking

Hacking Core

Isn't just about patching files

Runtime Patching

Adds CPU, memory, debugging overhead

Services in Drupal 8

Enable best-practice runtime patching.

Dependency...

Heaven?

Composer

De facto PHP dependency manager

No more* copy paste!

Vendor projects removed from Drupal repos

*Soon, expected in Drupal 8.1.

Coreless Site Repos

Build your entire site using just composer.

No more Drupal Core in your site repo.

What about Non-Drupal Developers?

OOP Everywhere!

PHP 5 fully implemented OOP

More than just Objects

Functional Pain

Groups of API functions not related at language level.

Requires more training!

OOP Groups Functionality

At the language level.

D8 Class Library

Create more functionality...

...with less copy & paste.

Reduced "Drupalisms"

Lowers barriers for developers to use Drupal.

Provides a familiar environment to learn new skills.

The Web Changed

No longer just HTML

Many endpoints only need content, not an HTML page.

Decoupled, Mobile, and Native Apps.

D7 was a poor REST Sever

Discouraged use of Drupal 7 as a backend.

Load Just The Things

Web services + progressive decoupling

Ready for decoupled front-end, mobile, and native apps.

Site Building Joy

Closing the Adoption Gap

Missing Functionality

Core alone was never enough in D7

Key contrib modules needed to make a complete site

Batteries Included

More Field Types

* Contrib in Drupal 7

Reference Field Types

Enable composite content.

Views In Core

Finally!

No more waiting to build a real site.

Views Dogfooding

Many core-provided pages are views!

Customize user and admin facing pages.

Config Management

CMI = Features in Core

Preserve configurations to files

Themer Happiness

PHPTemplate

Raw PHP in a theme is a bad idea!

Complicated syntax, security nightmare.

New Theme Engine

Twig means no more PHP!

Simplified Theme Layer

More theme templates, less functions.

Business Owner Bliss

No more upgrades

6 to 7 Upgrades Hurt

Module incompatibility, past mistakes, no rollback.

Easier, more cost effective to build a new site.

Migrate in Core

Repeatable & customizable content migrations.

Cruftless

Old DB tables and config left behind

Supported from Drupal 6

Transfer content directly from 6 to 8.

Config Deployment

Easier to Update Prod

With core alone.

The Drop Picks Up Speed

Development Cycle Problems

Lengthy Dev Cycles Kill Momentum

And contributor interest.

Semantic Versioning

Predictable releases every ~6 months.

Long Term Support when next major version starts.

More than Just Good Feels

Lets contributors see the value of their work...

...before they forget.

How OSS Gets Updated

Conflicting priorities

Easy/fun vs. Most Critical

Subsystem dependencies

Technical Debt

"I don't have the time to do it the right way."

Shortcuts, brute force, and "temporary" workarounds.

Incremental Updates

Define an endpoint several releases away.

Focus on one big change per release.

Mirror Universe

Great in Theory

More focused changes, less "too many cooks"

Less Perceived Work

Easier for volunteer core devs to maintain momentum

Easier for Contrib Devs

A focused change takes less time to update modules

Incremental's advantage?

It limits cultural shock.

Fewer changes make it easier to accept.

So, why didn't we do that?

Drupal 8 was a "Big Bang" Change

All changes in one version jump

Big Bang is Organic

Feature Creep

It's not just for new features...

...but for fixing things that were unplanned.

Often requires a Tyrant

Or, at least someone that can say "No".

'No' isn't the same in OSS

It discourages volunteers instead.

"Make it happen"

Doesn't encourage unpaid contributors

...they leave instead.

Drupal isn't an iPhone

And we're not working for Apple.

Big Bang is Exciting

Maybe not for existing developers...

But it has the effect of creating new interest!

It'll Just Hurt...Differently

Work is not really reduced

...only the perception of the amount.

How's this sound?

Rewrite your modules...

...every 6 months...for 4 years?

Incremental can be Exhausting

Both for core developers...

...and contrib developers.

Band-aid Problem

Incremental Updates

Can create a "lost version"...

...by exchanging cultural shock, for update fatigue.

Big Bang is a Mental Reset

It's easier to be a new student...

...than an old expert.

The Promise of Drupal 8

A Technical Leap

OOP, Twig, Symfony, and more.

Process Improvements

The Drop moves faster.

Ready of the Box

More of what you need in core.

A Long Slog

But a brighter future.

Not just invite in

But also venture out

Drupal 8: A Great Opportunity

Both for today's Drupal devs...

...and those we'll meet tomorrow.