Beginners guide to Drupal

Ultimate guide to Drupal for Beginners

In one of the earlier posts featured  What does a Drupal Developer do? We discussed about the role in general and how Drupal developers fit into different profiles.

We also spoke about the Skills a Drupal developer should have. In this post I will mention some of the things I have missed in the previous articles with the main focus being resources.

Learning to be a Drupal developer

This is not a very difficult task but you should know how. Know that Google is your best friend. I tell this to every newbie I see seeking help from seniors. You know what they do that you don’t? They know how to Google and yep that’s a thing. Of course they know a lot more than you do but there comes a moment even with the best developers when they look outside for answers.

What you should do?

You will need to learn to Google. Use keywords period. You want to know “How to build Drupal theme using Bootstrap” don’t type the whole thing on Google, instead type “build Drupal theme using Bootstrap” cut out those extras and use only the keywords.

Where to look? is the best place to find a ton of material to begin with and of course there are various other websites, books and podcasts.


Modern PHP programming

What you should know

  • Programming patterns

  • Factory methods

  • Dependency injection

  • Namespaces & PSR-0

  • Modern Object-Oriented PHP

  • Classes, objects, inheritance

  • Late static binding

Drupal 7 and its predecessors had basic procedural PHP programming mostly except for Drupal core, hook patterns and a few APIs would suffice but with the introduction of modern concepts of PHP in Drupal 8, you are required to work with advanced OOP patterns and syntax.  



What you should know

  • Symfony2 components form the basis for D8

  • Drupal 8 doesn’t work like Symfony2

Drupal 8 and Symfony2 share PHP libraries, knowing Symfony2 will help you learn Drupal8 better, of course these two individually solve different issues but there are a few things knowing which will help you to be a better developer. The Symfony website is the best place to learn about it. You should know about EventDispatcher, HttpKernel and HttpFoundation, ClassLoader, YAML, Routing, DependencyInjection, Twig, Process, Serializer, Validator, Translator.


New 3rd Party libraries

  • Guzzle – for fetching content from URLs (replaced drupal_http_request)

  • EasyRDF – for parsing RDF into PHP

  • Zend_Feed – for processing Feeds


What you should know

  • What is Composer and how does it work

  • When do you need to use it

Composer is a dependency management tool for PHP used by Drupal 8 to handle its PHP dependencies, such as Symfony and Twig. composer.json is available at /composer.json, which follows a schema to define the version dependencies for each package.

It helps with handling dependencies and subsidiary dependencies with locating, downloading, validating, and loading said packages, while ensuring that exactly the right versions for each package is use.



What you should know

  • Simpletest is replaced with PHPUnit, more or less

  • Learn to use PHPUnit

The testing framework PHPUnit has been added to Drupal 8. Simpletest is still supported but should only be used for web tests and DrupalUnitTest's that require a complete or partial Drupal environment.

PHPUnit is the de-facto standard tool to write (unit) tests in PHP and offers a long list of advantages over Simpletest, such as overall better API's, Mocking, an improved test runner, code coverage report generation and more.




What you should know

  • How to find, create, load and work with Plugin’s

Plugins are small pieces of functionality that are swappable. Plugins that perform similar functionality are of the same plugin type. These are useful for extending or modifying both core and contrib behaviour. They offer more flexible architecture and make it easy to customise Drupal in a way that is also flexible.

Some terms you’ll need to be familiar with:

  • Plugin types

  • Plugin discovery

  • Plugin factory

  • Plugin derivatives

  • Discovery decorators

  • Plugin mappers


Entity API

What you should know

  • Entities are Classed objects with a defined Interface

  • Fields are bound to entities, and no longer shared across bundles

  • How to access entity properties and fields

  • How to define new Entities

Drupal 8 introduces a more feature rich entity API with full CRUD support in core. Entity forms have also been introduced to simplify the creation and management of entity forms.

  • Entities are now classed objects that implement the Drupal\Core\Entity\EntityInterface.

  • The default implementation is the Drupal\Core\Entity\Entity class.

  • Entity create, update, and delete functionality is now provided via the interface.

  • Users, nodes, comments, files, taxonomy terms and vocabularies have been converted to extend the new base class and interface.

  • entity_uri() and entity_label() have been removed in favor of methods.

The Entity API in Drupal 7 was limited. Drupal 8 expands it heavily in order to provide better tools and flexibility for working with entities.


Configuration API & Configuration entities

What you should know

  • How to load and save config data

  • Creating and working with Config Entities

  • How config data is managed

  • variable_get() and variable_set() are gone

The configuration API provides a central place for modules to store configuration data. This can be simple static data like your site name, or configuration for more complex business objects like field definitions or image styles. Contrib module developers can commit YAML files in a module/config folder defining the structure of their configuration settings.

In addition, Drupal 8 gets config entities, which are like regular entities only they are used for configuration – not content – and are not fieldable, and use the Config API for storage, not the database.



What you should know

  • How to write Symfony2 routes

In Drupal 8 we are using the Symfony2 Routing component, so we are able to split out the route handling aspect, and get a much improved and feature-rich solution. For example, this allows us to have multiple routes based on Accept headers, enabling RESTful web services.



What you should know

  • Many Drupal functions are now “Services”

  • What are Services and how do they work

  • Accessing and injecting Services

A Service is any PHP object that performs some sort of "global" task. Each service is used throughout your application whenever you need the specific functionality it provides.

A Service Container (or dependency injection container) is just a PHP object that manages the instantiation of services (i.e. objects).

In Drupal 8, we use the Symfony Service Container component, and Services are defined in YAML files. One example is the Drupal::moduleHandler() service, which replaces a lot of functions dealing with module management.


Object-oriented forms

What you should know

  • Forms are now objects, built from a common interface

  • Extend \Drupal\Core\Form\FormBase for common form functionality

In Drupal 7, forms were built by a procedural function, and validation and submission were provided by magically named functions: the name of your form building function, followed by either _validate or _submit.

In Drupal 8, there is now an interface called FormInterface. It has four methods:

  • getFormID()

  • buildForm()

  • validateForm()

  • submitForm()

The form is called in mostly the same way as before, using drupal_get_form(), or via a route, however now we pass the class name instead.


Drupal 7 and 8 are different in a lot of ways and while I was writing this article one of my colleagues pointed me to the list about changes in the versions.

I owe it to all these people for this article,

DC Denison


A lot of people!