ideas@sullice.com

A New Era for Drupal's JSON:API

On Monday (2019-9-16), I published the 8.x-1.0 version of the JSON:API Hypermedia module (hypermedia is just a fancy name for things with links). It took lots of work in my current role at Acquia and I depended on the help of my friends (and colleagues) Peter Weber (zrpnr), Wim Leers (same), and Mateu Aguiló Bosch (e0ipso).

I believe this opens a new era in the decoupled Drupal ecosystem.

What does this module do? It provides an API for modules to add links to JSON:API responses .

Neat, right?!

Oh… why does that matter, you ask? Well, before I answer that, let’s think a little more deeply about the web that we know and love and the links that drive it.

Sunshine, Rainbows and Release Cycles: Drupal 9 and Beyond

I think there are some misconceptions about [Drupal’s new major release cycle and] what it means for Drupal projects … so let’s take a little look under the hood.

Third-party Content Synchronization with Drupal Migrate

Sometimes you need to pull in content or data on an ongoing basis from a third-party product or website. Maybe you want to pull in a list of books from Amazon, or show some products from your Shopify store. You may need all the flexibility of nodes in Drupal, but you don’t want to copy content manually, and you don’t want to be forced to move away from those other systems that are already serving your needs.…Here’s a recipe for synchronizing content from outside websites or products using the Migrate module.

The Art of Doing One Thing Well

It’s ingrained into nearly every programmer’s psyche … When a function gets too big, break it out into smaller ones. When a class gets too complex, break it down. It’s the essence of the Single Responsibility Principle: do one thing well.… While this good practice is etched into our brains, the actual art of composing complexity out of small, simple components is not so well developed in many of our minds. How should we break things out? Where are the component parts that can be separated? When is a little copying better than a little dependency?

Testing for the Brave and True: Part One

This is the second part of a series of blog posts about automated testing for Drupal. Its mission is to take you from zero testing experience to confidence in testing your custom Drupal work, from the ground up. Last time, in Testing for the Brave and True: Part Zero we defined exactly what automated testing is and discussed some of the common vocabulary of testing. It also introduced the two primary tools used by the Drupal community to test their work, PHPUnit and Behat.

Testing for the Brave and True: Part Zero

“If you’re not testing, you’re doing it wrong.” I can’t remember how many times I’ve heard those words. Each time, I’d feel a little pang of guilt, a little bit of shame that every day, I wrote code for myself and clients that wasn’t tested. I’d be frustrated with the developers who repeated that mantra. Sure, it was easy to say, but hard to live up to. How do I test? What do I test? Should I test? How would I justify the costs?

Drupal's Weak Link

One of the things I love about Drupal is the entity reference field. … However, I think as Drupal developers and architects, we’re fundamentally misusing them in far too many cases. … Mere entity references severely limit our ability to create rich, rational content type architectures and force us to jump through additional hoops and write more custom code than ought to be required. I believe that Drupal having only entity references to forge relationships between content types is a major shortcoming.

Introducing an HTTP API for Drupal 8 Entity Queries

Entity Query API allows API consumers to make queries against any entity in Drupal. From users, to nodes, to configuration entities, this is an incredibly powerful tool. By creating a standardized set of parameters for crafting these queries, Entity Query API allows developers to create generalized tooling not tied to particular views or entities.

Drupal Permissions Done Right

You’ve been doing Drupal permissions wrong for years (probably). And the fix is pretty simple.

A Reluctant Guide to Vim

Face it, it’s better than nano and easier than emacs. You’re going to edit some file, somewhere, sometime on some server. You won’t be able to click to move your cursor or scroll to the bottom of a 2000 line long configuration file. As it would for any developer, holding down the arrow keys will get old, fast. This is the reluctant guide to Vim. I’m not going to try to convince you that Vim is God’s gift to man. Here’s the low-hanging fruit that got me hooked, maybe it will hook you too.

Cleaner Code with Functional Concepts

As developers, we’re all constantly searching for the cleanest way to write something. Writing that elegant one-liner or refactoring something ugly gives us a deep sense of satisfaction. Unfortunately, working with Drupal forces us to deal with deeply nested arrays that encourage ugly, cumbersome code. … There’s another way though… With some simple concepts from functional programming, we can avoid those ugly, deeply-nested loops and conditionals that we often see in the Drupal ecosystem.

Faster SQL Syncs with Command-line Magic

Sometimes, we’ve got to stop and examine why we do things the way we’ve always done them. One of the most mundane parts of working with Drupal every day is syncing Drupal databases with Drush. At this point, I think my fingers just write drush sql-sync on muscle memory. There is a faster way though…

An Introduction to Containers

Containers are an incredibly powerful tool for deploying and scaling sites. For a long time, though, I felt as though I’d missed the boat on what they are and how to use them. Every post I could find was a tutorial that explained how to start one, but not what they are. This is the post I wish I had found first. It’s not a tutorial and it’s not about lessons learned. We’re going to start with the basics and work our way up to understanding containers as a concept.