In threads like #1255674: [meta] Make core maintainable, we've been discussing a variety of different approaches for improving the process of maintaining Drupal core. One of the most popular solutions is taking stuff out, but other than a few whipping-boy modules (cough profile cough trigger), there's very little consensus on what should be removed, and why it should be removed.

Moving forward, we need some good heuristics that can be used in three situations:

  1. When new functionality is being proposed for Drupal core
  2. When existing core functionality is being evaluated for removal
  3. When major refactoring of existing core functionality is being proposed

These heuristics can't be hard and fast rules like our coding standards, or a task-oriented checklist like the Drupal 8 Gates -- they're intended instead as a general measure of how well a proposed change aligns with the Drupal Project's shared needs. Specifically, the questions should help guide new "Code Gardeners" as they evaluate patches and proposals. Being able to say, "Yes!" to all of these questions doesn't automatically mean a patch is RTBC, but it certainly indicate that something is a good fit. Similarly, getting "No!" answers doesn't mean that a change would be rejected or a module would immediately be jettisoned, but it would definitely raise red flags.

Based on my own brainstorming, and subsequent conversations with Catch and Sun, I'd like to propose the following "rules of thumb":

  1. Is it needed for Drupal web sites, automated tests, installation profiles, or drush commands to operate properly?
  2. Is it a "defining" quality of Drupal or an important differentiator from other web CMS projects?
  3. Is it a "building block" that can be used to implement many different user-facing features?
  4. Can it be controlled or managed from a variety of tools (drush, GUI admin tools, install profiles, packaged configuration, etc.)
  5. Would it be impractical or impossible to implement as an optional plugin or contrib module?
  6. If more robust solutions to the same problem exist in contrib, is it compatible with or "easily migratable to" the contrib solution?
  7. Does it have a positive or neutral impact on the number of "tightly coupled" connections and dependencies between different parts of Drupal?
  8. Does its presence significantly improve the experience of first-time evaluators, experienced builders, or developers building on top of Drupal -- without significantly diminishing the experience of the others?
  9. Does it match common patterns and best practices for similar tools and web applications?

All of the questions above are positive criteria, and none are specifically intended to "catch" a particular hated or loved piece of functionality. They can apply equally to modules, specific features, and underlying API changes. There are some domain-specific questions that aren't covered (like accessibility, UX concerns, and product/api separation), and it doesn't include any specific guidance for how removal of functionality should be handled for upgrade purposes, but those are implementation questions that have to be ironed out on a patch-by-patch basis, or are already covered by our "Drupal 8 Gates."

Comments

eaton’s picture

Also, there are 8 questions. For Drupal 8. If I'd posted it on August 8th it would be a lot cooler, but I'll take the synchronicity where I can find it.

webchick’s picture

Thanks so much for splitting this productive discussion off from the Thread of Doom™. The criteria looks pretty great at first glance. I'll take a closer look later.

sun’s picture

Issue tags:+Platform Initiative
philbar’s picture

Issue tags:-Platform Initiative

Have we decided against "Core as Framework; Distributions as Product"?

This issue is mute if we go in that direction. Going the distribution route, we'd be best served to strip everything out of Core except the framework and bring in all the modules back in from contrib in packaged distributions.

philbar’s picture

Issue tags:+Platform Initiative

retagging

eaton’s picture

This issue is mute if we go in that direction. Going the distribution route, we'd be best served to strip everything out of Core except the framework and bring in all the modules back in from contrib in packaged distributions.

On the contrary, these questions are still essential even if we switch to a distro/packaging model. Whether we're using separate git repositories or a different packaging system, we still have to make decisions about what the "Primary Drupal Download" contains, and what the essential "core" software package contains.

Pursuing a distribution based model will help some of the "conflicting needs and priorities" problems that we see, but it won't magically allow us to avoid these questions.

catch’s picture

I tried to deal with the false dichotomy of framework vs. product in http://ca.tchpole.net/node/4. These heuristics can be applied to very low level APIs as well as particular end-user features and lots in betweeen. The packaging approach allows you to split, but it does not determine exactly where that split is (or that you can do the splits without pulling a muscle).

Michelle’s picture

Thank you for #6. :)

Michelle

philbar’s picture

I tried to deal with the false dichotomy of framework vs. product in http://ca.tchpole.net/node/4. These heuristics can be applied to very low level APIs as well as particular end-user features and lots in between. The packaging approach allows you to split, but it does not determine exactly where that split is (or that you can do the splits without pulling a muscle).

I'm trying to clear up is whether this is a discussion about the split between...

  • Drupal Product and Contrib
  • OR...Drupal Framework/Platform and Drupal Product(s)
Michelle’s picture

I read it as a split between things that are handled by the core development "team", regardless of how the framework/product discussion ends up, and things that are handled by contrib maintainers.

Michelle

eaton’s picture

I'm trying to clear up is whether this is a discussion about the split between...

Drupal Product and Contrib
OR...Drupal Framework/Platform and Drupal Product(s)

It's not a discussion of either. It's a discussion about what "rules of thumb" can be used when weighing a particular piece of functionality for inclusion, removal, or refactoring. There are other issues in which the "distro model" and packaging split are currently being discussed, but they'll need to ask the same questions. If you want to remove things from the "core' system, you still have to determine what functionality stays in. Thus, these questions remain valuable. ;-)

For clarification: this is not a thread about whether we should move modules out of core into contrib. It's a thread about the kinds of questions we can use to decide if something is appropriate for inclusion in the primary Drupal download that users get from drupal.org. Thanks!

philbar’s picture

It's a discussion about what "rules of thumb" can be used when weighing a particular piece of functionality for inclusion, removal, or refactoring.

Are we talking about what should be included, removed, or refactored in the core as the "product"?

If so, then this discussion will completely changed if we move to a distro model because we won't have ONE product...but many.

So we really need to know this first: Is core going to be the product in D8? Or will there be multiple products for D8?

eaton’s picture

I think we're talking past each other, philbar. The questions above are written to be applicable regardless of that split. In fact, they are written to help us make intelligent decisions in the event of that split. If you want to argue for or against the profile/distro based model proposed in #1260214: Choose your Drupal, that's the better place to do it.

If you think there are specific criteria in this post that simply wouldn't make sense if we went to a distro model, that probably makes sense to flag and discuss here.

jherencia’s picture

Crell’s picture

I don't follow item 4. If something can be controlled from multiple UIs, it should be in core? If something can be controlled from multiple UIs I'd say that's a good thing in general, but I don't think that automatically means it belongs in core.

And subscribing. :-)

eaton’s picture

I don't follow item 4. If something can be controlled from multiple UIs, it should be in core? If something can be controlled from multiple UIs I'd say that's a good thing in general, but I don't think that automatically means it belongs in core.

I think you're misunderstanding the intent. If something is being proposed for addition to Drupal core, and it can be controlled in multiple ways (drush, installl profiles, web UI, standardized APIs, etc), it has "core-like-qualities." That doesn't mean that it SHOULD be in core, but it means that in one particular way, it will fit in well with the way that we want core to work. :)

Everett Zufelt’s picture

There are some domain-specific questions that aren't covered (like accessibility,

Whether a particular component is accessible should not be a factor for its theoretical inclusion in Core. Whether it is possible to make such a component accessible ought to be a criteria. Clearly this almost always only applies to components with a UI.

E.g. Should a modal dialog component be added as a renderable element in Core? One would, at least, want to know if it is possible to make the modal dialog UI pattern accessible.

attiks’s picture

sub

eigentor’s picture

@catch I was wondering if trying to sort APIs and core modules into your model of Levels and sorting out dependencies in a graphic picture could help decide how low-level stuff is and how other stuff is building on it.
Sorting out these Levels and getting clear where stuff is might help.

e.G. if there is something that is very low-level and this part of Drupal is old cruft but lots of other parts depend on it, this is where work would have to start.

Working from the bottom upwards gives some Logic and order to this otherwise tangled mess.

catch’s picture

@eigentor I think that'd be great, but it also runs the risk of looking like this at the moment. However if we didn't look too closely at some of the circular dependencies I reckon it'd be doable to come up with something.

eigentor’s picture

I started out over here https://docs.google.com/drawings/d/1QVqmARfsYeyA22j9OuLHCp18cNgeX4f4dIBL...
This should be editable to anyone.

I guess it makes no sense to try to list everything on there.
Also it probably makes no sense for now to list all the dependencies, this would be another graphic. There could be more dimensions inside the area, as to how old and outdated parts are, which could be indicated by color, how much code certain parts contain, which could be indicated by size and shape of the bubbles (there are lots of shapes available = fun :) ). Color stuff red that practically everything depends on, or maybe that is totally outdated and a pita for all progresss...

I am not sure if this becomes useful, but all this talk about modules and elements can at least made be visible with such stuff. And nothing depends on Blog module and is clearly a product-type kind of feature: to the utmost top right it goes.

philbar’s picture

If you think there are specific criteria in this post that simply wouldn't make sense if we went to a distro model, that probably makes sense to flag and discuss here.

If we don't have a clear definition of core to start with, how are we ever going to come up with criteria on what to include in core. My concern is your list is too vague to be useful. Especially adding to the fact that it's not a hard and fast set of rules. If this is going to be a vague and subjective approval system is there really a point to having it?

Can you give me an example of how this list would help us figure out inclusion (or exclusion) of the following features:

  • Blog API
  • WYSIWYG
  • Content Creation Kit
  • Views
eaton’s picture

If we don't have a clear definition of core to start with, how are we ever going to come up with criteria on what to include in core.

Core is two things. First, it is "What people receive when they download 'Drupal.'" Second, it is "The stuff that is shared across all packaged distributions, and cannot be stripped out without altering the packaging system fundamentally."

In the future, packaging system changes may allow us to reduce the 'lowest common denominator of Drupal,' but that wouldn't render the discussion moot: it would just mean that we'd have to discuss all over again what the "smallest possible unit of Drupal" is. Thus, these questions or ones like them would still be needed to settle THAT question.

Can you give me an example of how this list would help us figure out inclusion (or exclusion) of the following features:

Sure. Let's take BlogAPI.

  1. It is NOT needed for sites, tests, profile, or drush to run.
  2. I'd argue that using BlogAPI to manage content isn't a defining quality of Drupal. It's not what people say "Makes Drupal Drupal" in any way. maybe it used to be in the past, but no longer.
  3. It's pretty sketchy on the 'Building block' angle; it allows nodes and nodes alone to be created via a remote API. I'm tentatively going to say no, it's not.
  4. The "Can it be controlled or managed from other tools" question is probably a yes, though not all of the questions map perfectly to every Drupal feature. But since it's meant to allow external API access to Drupal functions, sure.
  5. No, it ISN'T impractical for contrib. In fact it's totally orthogonal to other core code and could exist without problems in contrib.
  6. No alternative solutions exist in contrib, so one of the questions is moot.
  7. Yes, it has a neutral impact on the number of tightly coupled connections in Drupal. It basically just implements an XMLRPC endpoint and lets you create nodes with it.
  8. Although it can serve as a nice feature specifically for bloggers, I would argue that it does NOT significantly improve the experience of first time evaluators of developers or experienced builders. It's a nice feature to have but its presence in contrib is enoguh to satisfy the "I'd like to do that" urge, and it its absence isn't a huge roadblock for someone trying to get up to speed on Drupal.

So, based on those heuristics? Two positive answers out of eight, with one neutral/not applicable. While that doesn't mean automatic execution, it suggests that it's not well aligned with the needs of Drupal's "primary download exeperience." -- aka Drupal Core. Since it was generally considered a maintenance burden, and much of the blogging world has moved on do different standards like AtomPub, my gut feel is that the time was right to pull it out.

arianek’s picture

subscribe

jennifer.chang’s picture

subscribe.

beejeebus’s picture

subscribe. looking good to me.

webchick’s picture

One thing that I feel is missing from the proposed list of heuristics is something around user experience, matching user expectations, something like that.

Let's take the example of a separate administrative theme, which was added in Drupal 7.

---

- Is it needed for Drupal web sites, automated tests, installation profiles, or drush commands to operate properly?

No.

- Is it a "defining" quality of Drupal or an important differentiator from other web CMS projects?

No. Rather, the inverse; the *lack* of an administrative theme leads to a much steeper learning curve for new users and content editors because it breaks expectations that other CMSes set.

- Is it a "building block" that can be used to implement many different user-facing features?

No.

- Can it be controlled or managed from a variety of tools (drush, GUI admin tools, install profiles, packaged configuration, etc.)

No? (Sorry, I really don't understand what this one means; could probably use refinement.)

- Would it be impractical or impossible to implement as an optional plugin or contrib module?

Nope. Perfectly practical to implement in contrib, see Rootcandy, Rubik, etc.

- If more robust solutions to the same problem exist in contrib, is it compatible with or "easily migratable to" the contrib solution?

Yes. Just download another theme and change the setting.

- Does it have a positive or neutral impact on the number of "tightly coupled" connections and dependencies between different parts of Drupal?

Yes? I think it's neutral? But this heuristic could do with a bit more refinement, I think. Not quite clear how you would evaluate this on a feature-per-feature basis.

- Does its presence significantly improve the experience of first-time evaluators, experienced builders, or developers building on top of Drupal -- without significantly diminishing the experience of the others?

Yes.

---

So you have a separate administrative theme meeting 3 of the 8 criteria. Not much more than Blog API, really. And this was a super contentious thing when it went in, because core developers were used to how the old admin interface worked, they considered a separation between front-end and back-end something that other CMSes were doing it wrong, they misliked the process around D7UX, they thought the theme was ugly, they thought the theme wasn't flexible enough, and 100 other things.

OTOH, of all the D7UX changes, this was easily the single most beneficial one made, because suddenly our users have orientation. They know instantly, visually, starkly, the difference between when they are in an administrative context and when they are viewing their site as a user would see it. Suddenly Drupal behaves the way the rest of the Internet expects a CMS to behave. And our D7 usability testing gets to actually test D7, instead of testing the confusion around D6's Drupal's admin interface, because that all just fades in the background as a non-issue now.

So we need to ensure these heuristics empower the UX team to make sound, strategic, design decisions without core developers using these heuristics as a tool to block UX improvements they disagree with.

fgm’s picture

The admin theme example is indeed striking: the defining quality it brings to the experience rests in the API changes allowing the definition of an admin theme, which was somehow more easily defined in core. It did not rest in the actual admin theme being delivered, for which (better or not) alternatives exist in contrib.

So what you just demonstrated is the fact that a mechanism for an active theme had to belong in core so that its implementations could fulfill UX requirements, but that providing a core admin theme was not necessarily something to be provided by core.

In the platform/kernel/whatever vs product/distro/profile/whateverelse distinction, it seems this means it should belong to the latter, not the former, and yet the presence of an admin theme in core, as far as I can see, is not among the list of things to be removed. Which probably means something needs to be changed in these heuristics.

webchick’s picture

"So what you just demonstrated is the fact that a mechanism for an active theme had to belong in core so that its implementations could fulfill UX requirements, but that providing a core admin theme was not necessarily something to be provided by core."

No, what I just demonstrated was exactly the opposite. Drupal 6 had the mechanism in core to use alternate admin/front-end themes. It wasn't until we added an admin theme to core in D7 that our usability issues with user orientation went away.

chx’s picture

Maybe: Is it something that is a general expectation from any CMS? Say, this would keep signatures and pictures on users in core and yes, the admin theme.

David_Rothstein’s picture

@webchick says the admin theme meets 3 of the 8 criteria but I actually think it clearly meets a fourth:

"Is it a 'building block' that can be used to implement many different user-facing features?"

Yes, absolutely it is; a number of modules (e.g. Views) are now shipping with a Seven-specific CSS file (and putting lots of effort into making that experience top-notch) based on the idea that a whole lot of users will be using Seven to administer views.

That's 4 out of 8 right there. With @chx's/@webchick's suggestion of "general expectation from any CMS" (which could just be an expansion or rewording of the 'defining feature of Drupal' bullet) that's 5 out of 8, which seems like a good number to me.

Perhaps what's also missing here is something about "required or used by other parts of Drupal core" (this was being discussed in the other thread, I think, before this one split off)? In this case, Drupal core ships with the standard install profile, which wanted an admin theme in order to achieve its UX goals. (Now some people might disagree with the standard install profile being in core in the first place, but that's a totally different issue; taking it as a given that it's there, we obviously want it to work as well as possible.) Add something like that and it's now 6 out of 9.

Crell’s picture

eaton: It sounds like webchick is also confused by criteria 4. I still don't understand that one. From your description, it sounds like it only applies to plumbing code (which is fine). And then... something that is only usable via the GUI would get a -1 on core inclusion? But by the same token, that would imply that anything that can be controlled from multiple front-ends should be in core, which I don't agree with. I think that one still needs some work.

eaton’s picture

webchick, Bojhan, and I just chatted about this a bit in IRC -- I don't think that the situation would be quite as grim for the Admin theme as she thinks it would be -- I think it'd get a +1 on the 'Defining characteristic' question because there was an explicit decision to make separation between administration and visitor/user screens part of the core experience. If there's a difference of opinion on whether something should or should not be part of the defining experience, then heuristics can't answer the question and it boils down to judgement calls anyways.

BUT, along the way we did suss out two issues:

  1. Criteria #3 and #4 have a lot of overlap. #4 in particular -- "Can it be controlled or managed from a variety of tools (drush, GUI admin tools, install profiles, packaged configuration, etc.)" -- was intended to capture the fact that we want our code, and our building blocks, etc, to be installable and manageable in an automated fashion. Important code buried in form submit functions, heavy dependence on globals that can't be handled properly while install profiles are running, etc break that. BUT, those are things we need to treat as bugs and defects, not conceptual questions about how well something fits in core. They're implementation questions, not "does this belong in core" questions, and I think it's worth removing #4.
  2. None of our criteria capture the fact that we want Drupal to match users' and developers' expectations whenever possible. If there are common approaches to certain problems (UX patterns used by most modern web sites, reuse of approaches from other popular frameworks and libraries, etc.) and a given change either brings us closer to alignment with everyone else, or removes something that stands out like a sore thumb, it's generally a good thing. Something like: "Does this match common patterns and best practices for similar tools and web applications?"

Interestingly enough, this would have a neutral impact on BlogAPI module and increase the Admin Theme's overall score to 4/8 or 5/8, depending on whether you agree that separating visitor/user experience and admin experience should be a defining drupal characteristic. Given the contentiousness of the Admin theme and some of the related D7UX stuff, I think it reflects the fact that it took a judgement call and strong support from both core committers to "pull the trigger."

The goal of the heuristics, at least in my mind, isn't to be the final word on whether a patch should be committed. Rather, to capture how well a given change to Drupal's functionality matches pre-existing consensus in the development and user community about where we're at and where we're going. Disruptive changes -- things that fundamentally alter what people think of as "Drupal," for example -- are probably likely to score low because they require more discussion and consensus-building about "vision issues" we haven't yet agreed on.

eaton’s picture

Issue summary:View changes

Fixing Drupal Gates link

eaton’s picture

It looks like Crell came to the same conclusion about #4 in the interim. it's unclear, it overlaps with #3 depending on how you read it, and it's focused on implementation details (stuff we'd call a 'bug' even if there was agreement on the conceptual feature addition/removal). #4 is officially dead. I've stricken it from the list, though the numbering is still in place to prevent confusion as we reference different list items as this thread evolves.

catch’s picture

I'd like to add the 'does something in core depend on it' one from the other issue as well. That's a practical issue in terms of removing features (i.e. anything in the standard profile would be a prominent ux change). As well we should at least partially validate large api additions on whether they can replace/enhance things in core. I doubt we'd have committed uuid support unless there was a plan to use it later, and that might have prevented what happened with actions.

eaton’s picture

Is that an implementation detail, though? If something from core relies on a component that's being discussed for removal, it's not a conceptual question, it's a matter of feasibility. Removing it would cause actual loggable trackable bugs.

Maybe I'm missing the conceptual aspect of it... Hmmm.

catch’s picture

If we're adding components, whether something in core would be able to use them or not feels like a consideration. We currently have several features that are completely disabled, or dead code in includes somewhere.

eigentor’s picture

Maybe a criterion "Do many of the top 40 Contrib Modules build on it" could help. Which could not help Admin Theme in this situation, except that Views builds heavily on it which is a strong pro.

But stuff like Admin theme, and other, that define the UX, rather belongs in the default install profile rather than the core core, or is that a misunderstanding?
In an effort to shrink down the very core of Drupal, almost any user facing stuff is quite a few steps up the level-ladder.

The fact that the top 25 contributors contribute 85% of Drupal core patches (or whatever the numbers) creates a problem that renders a lot of this endevour useless (at least for the moment). As long as the same people that work on the very core have to maintain Snowman, there will be no relief in maintenance burden.

But being optimistic to have quite different maintainers for the more user-facing stuff in the future can paint a different picture.
I should hope that the further we go towards the user-facing level, the less knowledge of the lower levels people must have to contribute say to, Dashboard.

And if it is not possible to make this true the entire level system is not worth its gunpowder.

At least this is how I see the entire discussion: there is some stuff that may be really removed and moved to contrib, but the more interesting part is the seperation inside core, so the maintenance burden can be distributed between different interest groups.

And this again might attract different contributors: people that are proficient with Javascript but don't necessarily can nor want to understand field API.

dixon_’s picture

subscribing, reading, thinking

catch’s picture

Here's a good non-module example:

#308865: Drop IE6 support in Drupal core.

Is it needed for Drupal web sites, automated tests, installation profiles, or drush commands to operate properly?

No. Well unless you were using IE6.

Is it a "defining" quality of Drupal or an important differentiator from other web CMS projects?

No.

Is it a "building block" that can be used to implement many different user-facing features?

No.

Can it be controlled or managed from a variety of tools (drush, GUI admin tools, install profiles, packaged configuration, etc.)

No.

Would it be impractical or impossible to implement as an optional plugin or contrib module?
Security support would be impractical or impossible so was left in. edited to add, this required breaking down the 'feature' into more granular components (markup, css, js, security).

If more robust solutions to the same problem exist in contrib, is it compatible with or "easily migratable to" the contrib solution?
Not yet.

Does it have a positive or neutral impact on the number of "tightly coupled" connections and dependencies between different parts of Drupal?
Negative impact if you look at the patch that was committed - all kinds of IE6 hacks littered all over the place.

Does its presence significantly improve the experience of first-time evaluators, experienced builders, or developers building on top of Drupal -- without significantly diminishing the experience of the others?

No.

Does it match common patterns and best practices for similar tools and web applications?

No, lots of other tools and web applications are dropping it.

eaton’s picture

Wow. These criteria were harsh on IE6 support.

Crell’s picture

That's a mark in their favor. ;-)

I am concerned about the new criterion. What is a "similar tool and web application"? That almost begs the question of what type of tool Drupal is so that we can find something "similar". The answer to that criterion will vary widely depending on if you consider Symfony and Cake to be "similar", Zend and PEAR to be "similar", or Wordpress and Joomla to be "similar".

So while I support the concept there, we should be careful not to turn that into a circular dependency. :-)

SeanBannister’s picture

sub

thorandre’s picture

sub

eaton’s picture

I am concerned about the new criterion. What is a "similar tool and web application"? That almost begs the question of what type of tool Drupal is so that we can find something "similar". The answer to that criterion will vary widely depending on if you consider Symfony and Cake to be "similar", Zend and PEAR to be "similar", or Wordpress and Joomla to be "similar".

That sounds like a plus, at least to me; if WordPress, Joomla, TypePad, and others all take a similar approach to certain kinds of tasks, we'd best be very sure that we're making the right decision if we deviate. The intent was to capture the idea of general best practices in both web UX patterns and software design. DBTNG would've gotten a big YES in that category, because it was leveraging the kind of patterns that both PHP and many other web frameworks use for database abstraction. Having a web-based installer? Also a yes.

It's also an attempt to highlight "Not Invented Here" syndrome in progress. Perhaps there's a better way to capture that "Would someone coming from another system be baffled by this, or would it seem familiar" quality.

Dries’s picture

I like how this set of criteria is evolving. I think it could provide a healthy starting point for discussing whether something should or should not be included in core.

As long we use these criteria to support our discussions and decision making process, and not as a law to force a decision one way or another, I'm very comfortable with them as is.

Excellent work.

Crell’s picture

eaton: I think you misunderstand me. The point is what does "similar" mean.

"Is this something people coming from Wordpress would expect?" is a valid question to ask.

"Is this something people coming from Zend Framework would expect?" is also a valid question to ask.

You'll get very different answers depending on which of those questions you ask. :-) If we want to ask both, then we run into whether we want an AND or an OR. Should Drupal have everything that Zend Framework (a "pure" component framework) *and* Wordpress (an application) users are used to? That would be one really big core...

The answer may be "yes", but I'm just highlighting it as a potential bikeshed spot unless we have a clearer picture of what "similar" means. And that's before we even get into the various proprietary systems we compete against...

webchick’s picture

Can't it be contextual? If we're discussing an API change, it should be discussed in terms of larger PHP standards, interoperability with other systems, etc.

If we're discussing UI changes, it should be discussed in terms of what general web users expect based on de-facto standards and what other CMS-ish things do.

I guess I don't really see a need to spell it out that much. Obviously, if we're introducing a new HTTP library, we're going to be looking at Zend/Symfony, and not so much WordPress and PHPNuke.

eaton’s picture

Yeah, I don't mean to imply that we should be adding all the features of WordPress and Joomla and django and Rails and Zend and so on. Rather, that when we look to add something, we should probably ask whether we're doing it in a way that makes sense in light of other similar patterns throughout the web. Any thoughts on better terminology for that?

Crell’s picture

Perhaps something like "does it match industry best practices, standards, and expected conventions?" That side-steps the "similar" question and allows us to look at the web industry as a whole.

(An awful lot of what's going on in Drupal 8 dev right now is based on ongoing trends in the web dev industry as a whole, which I suppose would be a good sign.)

cpelham’s picture

I agree with #50 although I wonder if the word "observe" or "follow" would be better than "match"? That might be overly quibbling or not make any difference...

q0rban’s picture

Sub.

karschsp’s picture

sub.

Dave Reid’s picture

Very excellent questions and discussions raised here so far and how these can fit in and work with the proposed/finalized Drupal 8 gates.

Owen Barton’s picture

Regarding #45 "Would someone coming from another system be baffled by this, or would it seem familiar" - this is pretty well established from both a DX and UX point of view as the principle of least astonishment. It doesn't mean we need to copy from other systems, just keep to established patterns unless we have a very well defined reason for not doing so (and mechanisms to compensate for the inevitable astonishment!). We use this principle all the time on the small scale to assess if a patch/module has been built the "Drupal-way" or not - the difference here is that we are applying the same principle to the big wide world of web sites/frameworks/platforms/products/software.

effulgentsia’s picture

I like these criteria a lot. And I agree with treating these as discussion guiders rather than strictly formulaic. For example, something might come up that answers yes to only 1 of the criteria, but a very strong yes, and that might be as compelling as something that answers a weak yes to 5 criteria.

highermath’s picture

sub

kattekrab’s picture

/me more listening.

Also - finally, I'm beginning to feel less like I might need to abandon Drupal.

Hooray for defining the heuristics (my my that's a tricky word to get ya head around) for evaluating these fundamental changes to Drupal.

I don't know if it's been said elsewhere but I'm still digging through all the various threads trying to catch up.

Here's why getting this right is so important.

I'm not a site builder or themer, but they are the closest Drupal roles to describe where I connect with Drupal. Mostly I work with users who are dealing with a website someone else has built for them. Sites large and small. Some users have access as User 1, some don't. I may have worked on building the website, or I may have inherited a website built by persons unknown.

Much of the debate on the platform/framework v product and making core maintainable has literally made me feel like I needed to start looking for an alternative web product for myself, my clients, and for the future of my business.

The debate itself made me feel unwelcome. It made me feel "in the way".

At DrupalCon I was privy to a conversation where someone announced that Dries had just committed the patch to remove the blog module from Core. I use that module - on a number of different websites. So... that left me wondering if I'd ever be able to upgrade those sites. Blog has been moved to contrib but I still have no idea if that means I'll ever be able to upgrade those websites.

I asked a question about migration and upgrade pathways during the core conversations that effectively got railroaded by some 'non-answer' that the migrate API would magically fix all that. Will it?

So... @Eaton - thank you for spending time unpacking all these issues, and posting with such clarity.

I'm still uneasy though. If the core developers of Drupal abandon anything that looks like a product, and no-one steps up to provide a distro or profile that actually delivers a product... where will that leave me? Or is that the point. People like me just shouldn't be interfacing with Drupal?

That's what I was wondering. So - yay for heuristics. Rather than simply amputating problem limbs without a thorough diagnosis of the disease, and possible cures. Looks like there's hope.

juan_g’s picture

Much of the debate on the platform/framework v product and making core maintainable has literally made me feel like I needed to start looking for an alternative web product for myself, my clients, and for the future of my business.

@kattekrab: Well, in fact the debate is in great part about improving the organization of those different Drupal layers, to better serve all Drupal developers, builders, and users. It does not mean at all that some layers are going to disappear.

It's true that sometimes a rather dramatic language is used to catalyze change, however it's clear that Drupal is an especially and increasingly successful open-source project. The problem is maybe too much success. ;)

[edit]

At DrupalCon I was privy to a conversation where someone announced that Dries had just committed the patch to remove the blog module from Core. I use that module - on a number of different websites. So... that left me wondering if I'd ever be able to upgrade those sites. Blog has been moved to contrib but I still have no idea if that means I'll ever be able to upgrade those websites.

Yes, blog was removed from core but of course moved to contrib, now at http://drupal.org/project/blog . See also #1263208: Upgrade path for blog module removal.

If the core developers of Drupal abandon anything that looks like a product, and no-one steps up to provide a distro or profile that actually delivers a product...

It's all right, many people are taking care of the product layer, including core contributors like Eaton (see the Snowman project). See also #1260214: Choose your Drupal, Additional distribution documentation, etc.

juan_g’s picture

Reviewing the useful eight or nine points of the Issue Summary, a possible #10 criteria to also take into account could be related to the following from webchick. It's a two years old quote, but equally clarifying and remarkable today:

My personal philosophy is that core should be the home of features that 80%+ sites need, and provide necessary APIs so that everything else that could possibly be needed for building everything from an IRC daemon to a Facebook clone to a personal brochure-ware site. Drupal core is not in the business of competing with PHP-Nuke and cramming every feature possible into it; in fact, just the opposite. If I am building an IRC daemon or brochure-ware site on top of Drupal, I have no use for user-swappable themes, or buddylists, or favourite lists, etc. even though those are considered critical features of my Facebook clone site. However, in each of those cases, I do want features like user authentication, permissions, localization, etc. This cross-over spot is the business of Drupal core.

Every feature that's added to core (esp. if it's not encapsulated in a switch-offable module such as per-user themes) is more code that needs to be parsed on every single page and more code that we need to maintain over time. There is a large movement in the Drupal community for a smaller core that does nothing more than the basics and adding more robust tools for packaging "Distributions" of Drupal that can be catered to specific use cases, many of which may include per-user themes as a baseline feature. I'm highly in support of efforts that enable this, and far less in support of efforts that glom on legacy features, particularly when they make little sense and make core development more difficult.

So, it's possible that later the primary or most popular download from drupal.org will be, rather than core, maybe an official Drupal distribution, edition, or bundle for site builders, or another one for users, with core and a selection of contributed modules with their own maintainers, like Views, etc. (Similar examples for Drupal 6 are Acquia Drupal, and Cocomore Drupal).

Core would be just the central framework section, that is the section maintained by core developers, and also available as one of the two or three main downloads.

A partially related issue, that could help with some aspects of this is #1036780: Drupal.org should collect stats on enabled sub-modules and core modules . Of course, the above quoted criteria is, rather than about usage stats, more about the common basis.

klonos’s picture

#1036780: Drupal.org should collect stats on enabled sub-modules and core modules should be a major factor when deciding what to remove.

AaronMcH’s picture

Hi everyone

Going back to the good points about an administrative theme, I think these also apply to Toolbar and Overlay.

AaronMcHale

klonos’s picture

tim.plunkett’s picture

Version:8.x-dev» 9.x-dev
tim.plunkett’s picture

Issue summary:View changes

Removing Criteria #4 and adding Criteria #9, as per comment 33

catch’s picture

Version:9.x-dev» 8.1.x-dev