Larry Garfield aka crell: Drupal 8 Web Services Initiative Lead, a subsystem maintainer for a couple of things, relevant and Drupal representative to the PHP Framework Interoperability Group. Make sure you listen to the podcast for the full origin story of Larry’s online handle!
This conversation with Larry Garfield (@crell) is the first in a series of interviews Campbell Vertesi (@CampbellVertesi) and I carried out in preparation for DrupalCon Asia in Mumbai. We are building the world’s longest DrupalCon session and packing all 6+ hours of it with information and personalities you won’t want to miss! So actually ... For our one hour in the spotlight in Mumbai, we’ve been doing a lot of preparation. Our “session” will include a lot of additional materials like podcasts and blog posts about what we’ve learned along the way.
Our session, Meet PHP-FIG: Your community just got a whole lot bigger, Drupal is about Drupal 8’s membership in the new, interoperable PHP community. We’re covering the basics of what the PHP Framework Interoperability Group (PHP-FIG) is, what the various PSRs are and do, talk about testing and dependency management, and what it means to be a part of the new PHP community — including having better architecture, cleaner code, and more interoperability. All of this adds up to a big move to get projects “off their islands,” saving developers a lot of code, and companies a lot of money, among other benefits.
I apologize for the poor audio quality in this recording and hope the quality of the conversation makes up for it.
“I don’t want to speak to PHP from Drupal. I don’t want to speak to Drupal from PHP because that implies that those are different things that aren’t a part of each other or that I’m part of one talking to the other. That’s not the point. The point is that Drupal and PHP are not separate entities. Drupal is part of the PHP world and the PHP world is part of Drupal. That collaboration has helped us produce Drupal 8 and that collaboration I’m sure would continue to produce not just future versions of Drupal but better practices, more robust practices in PHP itself. So I would encourage everyone from these two large robust communities ... don’t look at them as two large robust communities. Look at them as different pockets of one larger community that we can all learn from, that we can all benefit from, and together we can build a better PHP for all projects.”More by or featuring Larry, further reading
- Getting off the island in 2013
- Building Bridges: Linking Islands (2014)
- Drupal & PHP: Linking Islands, the podcast – part 1
- Drupal & PHP: Linking Islands, the podcast – part 2
- Drupal 8: Happy, but not satisfied
- Larry’s challenge for us: “Giving Back in 2016. Contribute to other projects. Get your name on the contributors list for a new open source project.”
Larry: Okay. So a history lesson. The Framework Interoperability Group began life at php[tek] in 2009 in Chicago as the PHP Standards Group. We got together in a hotel room and said “With PHP 5.3 coming out and all these namespaces, it would be really cool if we all use them the same way and hey, we could do some cool autoloading stuff with that.” So the original goal was simply “Let’s collaborate and push this out to the community.” It was renamed to the Framework Interoperability Group in I think 2012. It didn’t really do anything more useful for several years.
In practice these days, pretty much any project that matters is using either the PSR-0 or PSR-4 autoloading standard. A project that doesn’t then has a huge amount of pressure to start doing so.
The PSR-2 coding standards: Most projects that are just random projects have now adopted tooling PhpStorm and phpcs, support by default, and there’s pressure on projects like Drupal that don’t use it to start using it just for conformity’s sake.
If you’re going to do anything new with HTTP messages now and you’re not already using Symfony’s HTTP foundation, you’re foolish to not use PSR-7 or something very close to PSR-7 because there’s a lot of tooling and tools built on top of that already.So who are the members of the FIG group these days?
Larry: There’s I think 41 or 42 members now. I don’t remember all of them off the top of my head. They’re listed on the website. I’ll say they include pretty much very major project except Wordpress. So Symfony, Zend, Drupal, Joomla, phpBB, about a dozen libraries like Monolog or Stash or Doctrine, some smaller libraries you may not have heard as much about like Jackalope. It really runs the gamut from really big players like Drupal to really small players like Jackalope and everything in the middle.What are some valid reasons why projects like Wordpress or individual developers would choose to ignore this interoperability movement, not take advantage of the PSR standards?
Larry: I think the biggest reason that projects wouldn’t follow PSR is legacy code bases. If you have a code base that’s been around for eight, 10 years or even just five years, you probably have a lot of internal conventions already built up and changing them is hard. Not like Drupal knows anything about that. ;-) So for a project like Wordpress where mission statement number one is backward compatibility, switching their logging system to use the PSR-3 logger would be an API break or at least extra API clumsiness so they’re not willing to do that. Certainly for a project by Drupal, switching our coding standards to PSR-2, whatever the technical benefits or downsides to that are, regardless of whether PSR-2 is a good spec or a bad spec, would mean changing literally millions of lines of code. It could be scripted to cover 98% of it fairly easily, but it still means every single patch and every single person’s local configuration and defaults in their IDE change. That’s not a small ask. So I think the biggest impediment to PSR adoption is simply existing standards, existing code bases, existing practices, which are sometimes legitimate complaints and sometimes not.Actually, there’s one comment which you made in your Drupal 8 launch blog post which I recommend for everybody to read ...
... continued: You mentioned actually one of the most significant things about the launch of Drupal 8 is proving that it is possible. Before we manage to do this, it was an open question, is it possible for the entire community to retool, change the entire API method of thinking and switch to object-oriented concepts and unit testability. We managed to drag one of the world’s largest open source communities through that and successfully launched a product. You’re right. It’s an enormous undertaking to understand other projects not wanting to do that.
Larry: I actually have a keynote that I gave called Eating Elephants that is that exact point of this is a lot of work. If Drupal can pull it off, so can anybody, but it’s still a lot of work. Not every project necessarily wants to go through that, the level of overhaul that Drupal did and not necessarilyevery project needs to. But I think over time, simply through natural project churn, most of the standards are going to become widespread in practice.What are the choices that people should be making now outside of implementing the PSRs?
... continued: So outside of FIG, of course FIG is just one part of a broader movement for interoperability and standard behaviors across no matter what it is you’re building with PHP. So what are some of the architectural implications of this exciting new world? What are the choices that people should be making now outside of implementing the PSRs?
Larry: I think the most important, just general good modern practices for collaboration these days are:
- use a PSR-based autoloader because everyone else is. It just using your code and sharing your code dead simple.
- Register it with Packagist because then getting it through Composer is dead simple.
- Use proper dependency injection because that makes it a lot easier to swap out pieces and plug your system into someone else’s ...
- ... which also means build your code in small standalone components rather than one big monolithic system.
This is really a movement that Symfony started with Symfony 2. It was the first project to really have a component library that was loosely coupled and then built a framework on top of it. Others have since done the same. Zend Framework 3 is moving heavily in that direction. The Aura project is strictly decoupled components with a framework built on top. A lot of major components now are completely standalone.
I think the biggest thing is think in terms of small, discrete pieces that you can mix and match. Same kind of Lego block approach that Drupal has striven for at the module level for years, even though we didn’t do a very good job of it at the code level all the time. We’re getting better. The more you do that, the easier it is to exchange code with people, the easier it is to reuse code, and also the easier it is to test.
Good unit testable code is also loosely coupled, is also easy to swap out, is easy to reason about. All of these concepts overlap on each other.
Testability, understandability, debuggability, ability to share with others all have the same underlying structure, underlying needs. So focusing on any one of those will make the others better.What are some wheels that we decided to bring in from outside in Drupal 8, rather than reinventing them?
Larry: So the big first wheel we got from elsewhere was our routing system which we pulled in from Symfony and along with that, a new architecture that spread throughout the rest of the system and took over. The template engine, of course, Twig is new and that’s been a huge win. Everything I’ve heard front enders adore it. That’s third-party code. The places we didn’t, the configuration system is primarily homegrown in large part because we needed the UI integration for it. Symfony’s configuration system, for example, assumes you’re doing configuration by editing files on disk. Drupal assumes you’re doing configuration by pushing buttons in the UI. These are fundamentally different assumptions and that same underlying tooling that supports one is not really going to support the other. Not very well.Drupal’s coming to the fold or gotten, become part of main line PHP. Talk about how this new world of interoperability has allowed Drupal to start making contributions outwards into other systems and other frameworks, other applications.
Larry: Honestly, I think at the moment, our biggest contributions are patches we’ve submitted to other projects, be that Symfony, Guzzle, Zend, whatever. Just being the poster child for this new PHP world. Drupal, being a demonstration that yes, it is possible to teach an old CMS new tricks, yes it is possible to embrace these modern tools and techniques, yes there’s benefits to doing so, you will survive. Honestly, I think that’s our biggest contribution is just proving that it can be done. We’re not the only project that has adopted lots of Symfony but I think just the evolutionary pressure we give that way is probably the biggest impact. It’s that the proof is in the Drupal 8 release, that it is a thing and it can be done and we should continue to provide that example of growth and of maturity enough to admit that you can change things. I think that’s probably our biggest contribution to PHP at the moment.So OO isn't so hard after all ...
... continued: I think early on when we were talking inside the community about adopting object oriented practices, about adopting some of the Symfony. A lot of the conversation was around Drupal being not so accessible for newbie programmers, people coming to write their first lines of code. It seems like it’s so much easier when it’s procedural. What I’m most excited about with Drupal 8 is watching what happens in the next two or three years as we demonstrate that anybody can code with modern practices, too. And that in fact, it makes it easy. If you can learn how an IF statement works, you can understand what a class is. So I think that’s another cultural export that we’re offering the rest of the PHP world.
Larry: You don’t have to be a comp sci grad from school in order to write in modern object-oriented code. We have thousands of people now from Drupal who have picked it up without being in school for it and are liking it.In the last few years, you’ve done a series of posts and sort of challenges to I guess the broader PHP world.
... continued: Initially, “Hey Drupal, we’ve got to get off our island and accept that we shouldn’t carry all this liability ourselves.” Then there was a building bridges post which said “Go visit people in other communities” and there was a challenge this year, build something in a project that’s not your home project. What’s your mission statement and challenge for all of us in 2016?
Larry: I know what I’m going to say. First one was go out and learn from other projects. The second one was go out and build with other projects. So I’ll say it now. Your challenge for this next year, contribute to other projects. Your goal is to get your name on the contributor’s list for a new open source project, some project that’s not your home project.Podcast series: Drupal 8Skill Level: Intermediate
This early scenario was originally released as a free download as part of the 'Original Adventures' series from Wizards of the Coast. Aimed at characters of around 2nd-level, it casts the party as unwitting agents of the deity Heironeous, whose scheme to punish a rather over-zealous (not to mention cruel) cleric has somewhat backfired.
With plenty of background material to ensure that the DM knows what is going on, the party is presented with a situation in the village of Newkeep - an ettin has destroyed the only bridge across a nearby river, and the villagers would like some help in dealing with it. A few hooks are provided in case the party doesn't accept the challenge at once, and then they can get on with attempting to track the ettin, lie in wait for its next visit (it has taken a fancy to the village cattle so comes nearly every night) or attempt to solve a cryptic riddle that's appeared on the wall. One they actually come face-to-face with the ettin, there's an interesting moral dilemma for them to solve...
It makes for a nice gentle adventure with scope for more than 'bash monster, take the loot', with a good feel of Newkeep as a place existing outside of the needs of a party of adventurers for somewhere to adventure in. There's a complete annotated map of Newkeep with the main locations and people described, and resources to help you run the party's initial arrival and subsequent investigations. Oldkeep, where the ettin has made its lair, is also mapped and described... and the ettin is not the only opposition that the party will face.
A nice adventure with a lot more to it than originally meets the eye, giving scope to develop the characters' personalities and style, a good one for a fairly new party.
Provides integration with bLazy to lazy load and multi-serve images to save bandwidth and server requests. The user will have faster load times and save data usage if they don't browse the whole page.Requirements
- bLazy library:
- Download bLazy from https://github.com/dinbror/blazy
- Extract it as is, rename "blazy-master" to "blazy", so the assets are at:
Once you get a new Drupal installed in your system, very next step you would like to change overall appearance of your site to make and feel good for end user. This is one the initial process require while setting up Drupal. Deciding about your design early will go long way in saving your time and repeated effort instead of doing it later.
Drupal 8 provides few built in theme that come up with the same package
e.g: Bartik, Stable, Seven, Stark, Classy.
if you don’t find any of them from given list then just go to drupal directory core/themes and open any theme info.yml and change hidden: true to hidden: false.
Drupal 8 is mobile-first approach. All built-in themes in Drupal 8 are responsive, with an…
Drupal 8 ships with a significant overhaul of the content creation page (“node form” for intimi). It’s design process and subsequent implementation are extensively documented on drupal.org. This is a high level summary of how this redesign come to be.Steps in the process:
Who were working on this? In the earliest design stages primarily 3 people: Bojhan Somers, Jared Ponchot and moi, Roy Scholten. Many more helped with finetuning design elements, usability testing, writing and reviewing code and all the other little and not so little things that go into getting a big design change committed to Drupal core. Thanks all.Research & sketching
We didn’t spend much time building the case for a better content creation page. No problem because most were already aware of the big room for improvement.
The research was two-part: “what does Drupal do?” And “what are other systems doing?” For the Drupal aspects, we looked at how and where contributed modules add functionality to this screen. We reviewed other systems looking for patterns in how functionality was grouped and arranged on the page.
That input was then translated into very generic concept sketches, comparing and contrasting several arrangements of the three basic feature groups: content, settings and actions. From there, we proposed to pursue one specific direction in more detail. Before we did that, we opened up the work so far for feedback: http://groups.drupal.org/node/214898Design
Starting from that very rough initial layout we started exploring the details of that arrangement. Which items belong in which area and how would they behave? How would it work on small screens? Which items to call out, which ones to push back?
Then Jared Ponchot stepped in and pulled all that sketching together in high-definition mockups. And on these we iterated again a couple of times, detailing the arrangement of interface elements, the use of color and other ways to (de-)emphasise certain parts of the whole. A comparison with the then current state of the Seven admin theme identified how we would have to extend its visual language to accommodate this new design.
And that’s where we opened up for another round of feedback: http://groups.drupal.org/node/217434Test
A working prototype of the design proposal was coded and made available on a test site. A usability test plan was drafted and several people used that script to test the prototype with people both new to and experienced with Drupal. One of the few times we actively pushed for community driven usability testing actually. Results from the testing were reported in the implementation issue and individual issues were opened for the necessary changes.
Usability test plan: http://groups.drupal.org/node/223959Implementation
The prototype for testing was created in context of the implementation issue. We spent a lot of time translating the design proposal into actionable tasks.
The distinction between rough prototyping code and actual core worthy implementation was a bit unclear at first but we very quickly got to a usable demo. The overarching “meta” issue has over 300 comments. Which is usually a sign of a large undertaking that’s not sufficiently broken down in seperate actionable tasks. But, we got there in the end!
Implementation meta issue: https://drupal.org/node/1510532Lessons (not? :-) learned
- Good: working with a small team. It allowed us to focus on what needed to be done and move relatively fast.
- Good: Publicly documenting the research and sketching phases was a lot of work but worth it. Pulling a finalised glossy photoshop design out of the hat would not have created the same engagement and constructive feedback
- Good: counter to the previous point but also a good thing was that the initial sketches and design mockups were shared only within the very small team of 3 to 5 people. This kept momentum up but more importantly allowed us to focus on the actual design work. A broader discussion would very likely have shifted towards discussing implementation challenges, which is not what you’re after when still exploring multiple options.
- Not so good: we prototyped only one working version quite late in the process. Only after a lot of time invested did we get to see and feel a somewhat working version. This narrowed our bandwidth for subsequent changes, which were relatively small tweaks, keeping the basic paradigm intact. We never really pitted two or more radically different approaches against each other. This was mostly a time and energy issue: we only had the bandwidth to work through one design direction.
- Not so good: Doing the design phases outside of the issue queue (where implementation happens). This was a necessary but difficult trade off. The issue queue doesn’t lend itself to explorative work with lots of ambiguity so the design work wasn’t tracked there. Many core developers did not closely follow the process as it happened on groups.drupal.org, so when we brought the design over to the issue queue with the proposal to go build this, much of the earlier discussion points got brought up again.
- Not so good: Not having a primary code architect as part of the team. We could have prevented at least some of the rehash in the issue queue if we had had a knowledgeable core developer on the design team. Having somebody who could answer to the technical implications of the design and help break down the work into manageable tasks the would probably have gotten us off to a better start with implementation.
A quick tally of the number of comments across the main discussion threads and issues for this project: more than 1200. And that doesn’t even include huge additions like the WYSIWYG editor and the improved previews. Not to say that this doesn’t happen in other initiatives, but you can see how demanding it is for anyone who wants to keep track, especially if you want to make sure that the big picture doesn’t get lost in the myriad of details.How to get better, faster?
The amount of work will always be huge. I think the gains are in finding a better balance in:
- Feeling free to write quick throw-away code in the initial explorations so people can get a feel of what might work and we can test it.
- Reducing wasted efforts (in code and discussion) during implementation.
Understanding the distinction between these two, and being clear about when the first ends and the second begins will already be a big step forward.
Further discussion: Determine process for big UX changesTags: drupaluxauthor uxdrupalplanetSub title: Drupal 8 has a redesigned content creation page. This is how it came to be.
We are working tirelessly to make Drop Guard better, faster and more friendly for developer. In this blog post we present you a "sneak peek" of our revamped project creation process, with this end in mind to please you with greater usability for getting started with your project in Drop Guard!
So let's get more detailed: the creation process will be split into 3 independent configuration screens.
1. On the first screen you will be able to quickly connect Drop Guard to your repository and enjoy it's updates monitoring capabilities - even without installing a Drop Guard module.
2. Second screen will be for those who immediately want to integrate Drop Guard in their daily maintenance routine. It's about telling Drop Guard what to do when the update of a certain type is detected.
3. Third screen will be all about events - sending e-mails, running SSH commands, pinging your favourite CI tool or merging branches based on certain conditions.
So below we share the preview of the new "Updates setup" wizard. As opposed to the "accordion-like" endless form, we now have the sleek step-by-step configurator, which allows you to quickly instruct Drop Guard what to do when updates are detected (embracing best update practices and being able to set a single configuration for different types of updates).This is a screenshot of the update types configuration in the old project creation process:
And here you can enjoy the sneak peek of the new process:
If you're a Drop Guard user or just curious - don't hesitate and leave your feedback on it. We'd love to optimize Drop Guard for every workflow and we can't do it without your voice! You prefer a personal contact? Find our data here: About Drupal Drupal Planet Project Process