Image
Showing 101-120 of 452 results
Coding for Drush Series
Blog postThis week we're releasing a new series, Coding for Drush. If you've ever used Drush, and wondered how you can create your own custom Drush commands, then this series is right up your alley. When I sat down to start planning the content for our recent Coding for Views series I found myself in a position where I needed to quickly generate a bunch of random data for a custom module’s database table, so that when querying the table with views there would be something there.
Release Day: Object-Oriented PHP Part 2
Blog postWe've recently switched from weekly releases to working towards releasing an entire series all on the same day. The Object-Oriented PHP Part 2 series is the first one we're doing with this. You get access to the complete series today! This second part of three on object-oriented PHP, provided by KnpUniversity, continues on from our Introduction to Object-Oriented PHP series.
We've added the last 13 tutorials for our free Hands-on Exercises: Movie Project, which covers building an entire Drupal 7 site, including site building, theming, and module development. The project is covered in 36 exercises, with the first 16 exercises focused on site building and theming. The remainder of the series has exercises that require module development, along with some performance testing.
More information
When your site is experiencing performance issues, one way to pinpoint the cause is to use profiling tools. Before you can fix the issue you have to be able to identify what's causing it. All profiling tools do roughly the same thing: they tell you what code is called during the request and how much time is spent executing it. This helps to identify the slowest code and dig deeper into the cause. Once the cause is determined you can start figuring out how to optimize the code.
For this tutorial, we’ll use New Relic as a profiling tool, but you can apply a similar methodology using the profiling tool of your choice.
In this tutorial, we'll:
- Learn how to identify and analyze slow transactions
- Look at common things to check for while profiling
- Cover some questions you should ask when looking at profiling data to help track down the slow code
By the end of this tutorial, you should know how to profile a Drupal site (specifically with New Relic) to find performance bottlenecks.
More information
Docker's goal is to treat containers as reusable, off-the-shelf pieces of infrastructure. Often, however, we need to tailor a container to our specific needs. We may need to enable debugging facilities, enable key configuration options, create databases, and set logins. Many development-oriented containers rely on environment variables to configure containers at runtime.
In this tutorial, we'll:
- Set environment variables using a static value in the Compose file
- Use an environment file to pass multiple variables at once
More information
Controllers are where you place the custom logic to dynamically generate the content of a page that a visitor sees when they visit a URL. When Drupal receives an incoming request, the HttpKernel identifies the appropriate route for the requested path, and the routing system matches this route with a controller. Controllers generate responses to these requests.
In this tutorial, we'll:
- Understand what a controller is in PHP and in the context of a Drupal module.
- Learn how to identify and interpret the role of a controller class.
By the end of this tutorial, you should be able to identify a controller class in a Drupal module and understand its role in generating responses.
Release Day: Get Started with Field API
Blog postRobust content modeling is made possible in Drupal 7 through fields. Attaching the right field types to entities makes it possible to bend your Drupal site to your will and scale it according to your needs. There are a lot of field types and field formatters provided in Contrib that you can download and install as modules to extend your Drupal 7 site. But what if you want to collect, store and format data in a particular way not provided by core or contributed modules? By providing custom fields and formatters through a module, you can control how your data is stored as well as provide one or more ways for the data to be output—through field formatters.
More information
Pantheon uses its Object Cache and Global CDN services to help improve the performance of your Drupal sites. Using them requires a few steps to enable the services and configure your Drupal site to use them effectively.
Many performance optimizations are hosting-provider-specific. This tutorial covers some Pantheon-specific methods for increasing your Drupal site's performance. It's only relevant if your site is hosted on Pantheon. For other common providers, and generic performance tuning tips, refer to other tutorials in this course.
In this tutorial we'll:
- Learn how to configure and use Pantheon's Object Cache to speed up Drupal caching
- Learn about the use case for Pantheon's Advanced Page Cache module
- Install and configure the Advanced Page Cache module for better Drupal caching of sites hosted on Pantheon
By the end of this tutorial you should be able to explain when and why you would want to use Pantheon's Object Cache and Advanced Page Cache modules, and how they can help speed up Drupal sites hosted on Pantheon.
More information
When working on configuration in a module, whether as part of a migration that uses Migrate Plus configuration entities, or while developing custom configuration entities, you'll often need to re-import the configuration stored in the .yml files of the modules config/install/ or config/optional/ directories. This is tricky though, because Drupal only reads in those default configuration settings when the module is first enabled. So any changes you make to those files after the module has been installed will not be reflected without these workarounds.
Knowing how to do this can improve the developer experience of adding (or debugging) the default configuration that's provided with a module. Or for anyone using Migrate Plus configuration entities as part of a migration.
In this tutorial we'll:
- Learn about the Configuration Development module
- Look at how you can use Drush to perform a partial configuration import
- Write an implementation of
hook_uninstall()to remove a module's configuration when it's uninstalled
By the end of this tutorial you should be able to re-import the configuration provided by a module without having to uninstall and then reinstall the module.
More information
In this video we'll look at two ways of finding files from the command line. We'll use both locate (and its friend updatedb) and find, and talk about the differences between them.
Note: this video was originally released June 8, 2010 on Lullabot.com.
Lullabot Module Monday in Videos!
Blog postFor the last two years Lullabot has been writing up a post about a new contributed module every week, in a series called Module Monday. We have almost 100 modules introduced in simple, concise articles. Here at Drupalize.Me we are going to start creating video versions of these Lullabot Module Monday articles so you can have a visual walkthrough of using these modules, in addition to the written overview that the articles provide.
More information
Note: This tutorial is specific to Drupal sites hosted on the Acquia platform and covers integrating its features to improve performance.
The Acquia platform includes Memcache, Varnish, and Content Delivery Network (CDN) integration. In order for these to be as effective as possible, they should be configured and tuned for your specific use case. This tutorial provides an introduction to these utilities and common configuration. For more detail, you should consult the Acquia documentation.
In this tutorial, we'll:
- Learn what caching utilities are included in the Acquia platform
- Set up and tune different parts of Acquia's application caching level including Memcache and Varnish
By the end of this tutorial, you'll know what application-level caching options exist on Acquia's platform. And how to configure it, and your Drupal application, for better performance.
More information
When writing containers for a local development environment, security is often a lesser concern. This is fine as long as we never intend to put the containers we create in a production environment.
When we do want to make production-ready containers, however, our priorities change. While Docker tries to be secure by default, it can't protect us from badly configured or vulnerable applications. For that, we need to design our images to be more secure.
In this tutorial, we'll:
- Outline the best practices for writing secure container images
- Introduce the
USERdirective - Set file ownership using
COPYandADD - Use the
RUNdirective to set file permissions
More information
Drupal core comes with a run-tests.sh script to help with running tests. This script has some distinct advantages over running tests directly via PHPUnit. It runs all tests in their own separate process, and can therefore handle PHP fatal errors without killing the test run. It's also the mechanism that the Drupal CI tools use to run tests; so, it can be handy when debugging tests that are failing on Drupal.org.
In this tutorial we'll:
- Look at the available options for the core run-tests.sh script
- Go through some examples of running tests using run-tests.sh
By the end of this tutorial you'll know how to run your tests using run-test.sh.
Introduction to Drupal
Guide
More information
It's best practice to access any of the services provided by Drupal via the service container to ensure the decoupled nature of these systems is respected. In order to do so, you need to know what services exists, and then, where possible, use dependency injection to use them in your code.
This tutorial walks through the process of:
- Discovering existing services and learn their machine name
- Using the machine name of service to request a copy from the service container
More information
A development environment is any copy of your site that operates separately from the live site. Development environments allow you to make changes, try new modules, write new code, and test new ideas on a copy of your site instead of the real thing. Using a development environment ensures any changes you make happen in a sandbox where you’re not affecting anyone trying to use the live version of your application. As a module developer, it's common practice to set up a copy of your Drupal application on your own computer for development and testing purposes.
In this tutorial we'll learn:
- What a development environment is and why it's needed
- The specific requirements for Drupal, and a recommendation (DDEV) for those seeking a straightforward solution
- Other commonly-used extras that enhance the development experience
By the end of this tutorial you should be able to describe the requirements of a Drupal development environment and know how to get started setting one up for yourself.
More information
Throughout this series we've been focused on working with a single set of containers and a single site. For most Drupal developers, however, we're expected to work with multiple client sites, sometimes several different ones in the same day.
When we add Docker into the mix, it can seem overwhelmingly complicated when you're used to working with other tools. Fortunately, there are several simple practices that not only work well with Docker, but also support your workflow.
In this tutorial, we'll:
- Outline the best practices when building a local development environment in Docker.
- Compare the differences in workflow when using Docker compared to other local development environments.
- Discuss various strategies to reduce resource use on team workstations.
Dependency Injection
Topic
More information
Dependency injection is a design pattern commonly used in object-oriented software architectures in order to support Inversion of Control.
In this post I'm going to give a little bit of insight in to how we are planning (and currently attempting) to migrate all the data from our current Drupal 6 site to our new Drupal 7 site using a couple of handy tools like Jenkins CI, bash shell, drush and the migrate module.