April 2014

That's right, at DrupalCon Austin we're going to make you sweat! Bring whatever issues you're working on, a list of what you want to learn, or just show up with an open mind, and we'll get you moving in the right direction. That direction being up up, move that body, down down, sweep the ground! (but in a completely metaphorical sense) The first "Ah-ha!" moment you have, you'll be awarded with the fabled, rarely seen BuildAModule sweatband - the Crown of Absorption, a rare and stretchy breed of Noggin Adornment that you currently can't get any other way.

If the sweatband doesn't grab you, maybe the 12+ trainers we'll have at your disposal will. Or maybe the 4 months of FREE BuildAModule membership you get. Maybe it's just having a chance to gaze at my visage for a full, uninterrupted 8 hours? Whatever your breed of motivation, we'd love to see you there.

Read more about the training, or SIGN UP NOW!

5 More New Videos on Event Dispatching in Symfony

Last week we started our dive into event dispatching - something that looks a lot like hooks in Drupal. This week we add some listeners to our dispatcher and refactor it to use OOP where possible. In Drupal 8, the Symfony event dispatcher replaces certain hooks like hook_init(), and Drupal 9 might see a shift where we replace all hooks with the Symfony event dispatcher. This means that wrapping your mind around this particular component will come in handy pretty quick now and could pay off big time down the road.

(FREE!) How to add a listener with our event dispatcher - 4:26

All right, now that we have en event, let’s listen for it! In this video we set up a listener to get triggered when our event takes place.

A recap of how we set up our event dispatcher and listener - 2:49

In this video we do a review of the steps that went into creating our event and listener with the event dispatcher component.

Adding a second listener and setting its priority - 2:51

Here we take a look at some additional options we can pass to a listener and create a second listener.

How to create a class for an event listener - 4:06

In the spirit of object orientation, our listeners should really be their own classes. Here we take our listeners and wrap some classes around them, which sets us up perfectly for the next step.

Reviewing the code in our event listener classes - 2:03

In this video we take a look at the code in our newly added event listener classes. Nothing too complicated, but we want to get a feel for the structure of the classes before moving on.

If you're considering taking the Acquia certification exam, it's probably a good idea to beef up on a few topics, even if you're a veteran. The certification program is still new, so it has yet to be seen just how valuable a meter it is for potential employers to gauge prospective employees, but the feedback so far has been generally positive. People who have taken the exam feel like the questions are thoughtful and that they reflect scenarios that a real-world Drupalist will have to deal with at some point or another. They're also tough. Like, sweating bullets tough. So, before plunking down the $250 to take the exam, it could do you good to review some material either as a refresher or to introduce you to the major topics that are outlined in the exam blueprint.

Because BuildAModule has been focused on dispensing practical Drupal learning for the last four years, we have a set of videos that map almost perfectly to the requirements of the Acquia certification. In addition to covering the broad topics, we also cover the in-between steps and concepts. From what we heard, questions on those in-between subjects are likely to emerge on the exam, so it could be a perfect fit, especially if you want to do some quick review.

Below is a mapping of BuildAModule videos to the Blueprint for the certification exam. Each heading is one of the domains or sub-topics that are evaluated. The paragraph below each sub-topic is a description of what BuildAModule videos are relevant to the topic. At this point, nearly all links point directly to BuildAModule. There are two other guides to other resources online, including Tanay's that references mostly Drupal.org resources, and Webchick's study guide.

Good luck!

Domain 1.0: Fundamental Web Development Concepts

1.1. Demonstrate knowledge of HTML and CSS

The video collections on BuildAModule assume a basic understanding of HTML and CSS, though we do go into how to rapidly test and adjust CSS using Firebug (the same skills apply to Chrome's developer tools). We also cover some common use cases for CSS such as hiding elements on the page and changing a background image.

One of the most common sites I've used sharpen HTML and CSS skills is at w3schools.com, though many people recommend Treehouse as well.

1.2. Identify PHP programing concepts

If you're new to PHP or to coding in general, the PHP Programming Basics will expose you to the most important techniques in procedural PHP programming with an angle towards eventually working in Drupal modules and themes. The exam doesn't appear to be focused on Drupal 8 yet, but you can also spend some time with our Object Oriented Programming (OOP) as well.

1.3. Identify JavaScript and jQuery programing concepts

We have an extensive chapter in the Drupal 7 Development Core Concepts collection on working with JavaScript and jQuery. In it, we look at how to add JavaScript inline or in external files, how to load JavaScript dynamically, how to use jQuery selectors and events, plus a lot more to fill in important gaps when working with JavaScript within Drupal.

1.4. Demonstrate the use of Git for version control

We created an entire series around using Git called Change Management and Version Control. In it, we first go through the process of installing Git and explain the major concepts behind version control in general. We then dive into the various Git commands and how to use them in a practical Drupal project. We also go over common branching strategies, like GitFlow, how to version control configuration from the database and a lot more.

Domain 2.0: Site Building

2.1 Demonstrate ability to create and configure Content Types with appropriate fields and field settings for building basic data structures

In the Build Your First Drupal 7 Web Site we go through the process of building a complete, practical Drupal 7 web site. Near the beginning, we explore how fields work and how to add new fields. We cover several of the default field types like taxonomy reference and node reference, as well as the Date field and Fivestar fields from contrib.

2.2. Demonstrate ability to configure field display and view modes for content types

We look at the field display settings in the process of hiding a field title (a common task). We also cover what view modes accomplish, how to choose the correct view mode for the right context and how to use the Display Suite module to modify and add new view modes.

2.3 Demonstrate ability to create and use Taxonomy vocabularies and terms for classification and organization of content

We start with a brief explanation of taxonomy and continue to explore how to add new vocabularies and terms.

2.4 Demonstrate ability to configure Blocks for building layouts from information widgets

After we discuss the role of blocks and what they are, we cover how to identify blocks as well as how to enable and configure blocks. We go through the processing of adding a new block and configuring its visibility settings. In a separate video collection called ]Advanced Site Building in Drupal 7](https://buildamodule.com/collection/advanced-site-building-in-drupal-7) we cover multiple methods for arranging blocks, including exploring the Context and Panels modules.

2.5 Demonstrate ability to build main and alternative navigation systems by using Menus

We have an extensive section on working with menus, including how to work with with the menu listing page, how to add and position new menu items. We explore working with secondary menus and adding menus as blocks. The videos around these sections also work through the nuances of working with the menu system.

2.6 Demonstrate ability to create and configure Views for building content list pages, blocks and feeds

After we dive into what the Views module is for and explore the basic components of a view, we go deep into several examples for using views to create a calendar-style list of events and also build a block to display a single piece of related content. We also explore using contextual filters and relationships (some of the more advanced and complicated features of Views). One thing we don't cover yet is how to create an RSS feed with Views.

Domain 3.0: Front end development (theming)

3.1 Given a scenario, demonstrate ability to create a custom theme or sub theme

Our Drupal 7 Theming Essentials walks you through the process of creating a theme from scratch as well as creating a sub-theme.

3.2 Demonstrate knowledge of theming concepts

In the first chapter of the Theming collection, called Important Drupal Theming Concepts, we discuss what theming is, review the numerous ways there are to modify the output of Drupal and how to choose the best method for each scenario. We explore the conventions behind view modes, field formatters and template files.

3.3 Demonstrate ability to build or override PHP templates for defining layout content

As we explore the various options for modifying the output of Drupal, we cover how to properly name and structure a template file and override existing templates.

3.4 Demonstrate ability to use theme () functions for overriding custom output

In addition to covering how to work with template files, we also demonstrate the process of creating a theme function and overriding existing theme functions.

3.5 Demonstrate ability to write template pre-process functions for overriding custom output

We cover the basics of creating a preprocessing function on the modular level or in a theme, and how to name them to work with templates or theme functions. We also explore ]how to get preprocessing functions to trigger only if certain conditions are met.

Domain 4.0: Back end development (coding)

4.1 Demonstrate ability to develop Custom Modules using Drupal API for extending Drupal functionality

In our Drupal 7 Development Core Concepts collection, we walk through the process of creating several practical modules. To begin with, we create a basic module to get a sense of the structure of the module folder. We walk through many common utility functions like l() and url() and dive deep into several APIs, including the Form API, the menu system, the Database API, the Node API and the user system. We also explore working with the theme layer and adding JavaScript and CSS files.

4.2 Demonstrate ability to work with Drupal's Database Abstraction Layer for managing tables and CRUD operations on data

We walk through the process of creating a module that manages the entire CRUD setup. We begin by explaining what the Database Abstraction Layer does, and then build the schema for our module using the Schema module. After that we work through the process of INSERT-ing, DELETE-ing and SELECT-ing from the database using the Database API. We also explore the benefits of writing a dynamic SELECT query and using hook_udpate_N() to keep module databases up to date.

4.3 Demonstrate ability to debug code and troubleshoot site problems

Throughout each of our video series, we talk through the process of troubleshooting problems with the site. The best way to get a feel for the various approaches you can take in narrowing down problems is to watch the videos in order and see how we approach problems when they arise. Throughout the development collections, we use Xdebug in order to inspect variables and stop code mid-way through execution. However, we also explore other approaches to tracking down specific problems. Doing a search on BuildAModule for "troubleshoot" will bring up some interesting videos, as well as a search for "error".

4.4 Demonstrate ability to write code using Drupal Coding Standards

Reviewing the Overview of Coding Standards section will bring you up to speed on how to make sure your code is good to go. In it, we talk through how to deal with white space, operators, comments and arrays, among other things.

4.5 Demonstrate ability to analyze and resolve site performance issues arising from site configuration and custom code

Improving performance is one area we haven't covered much on BuildAModule. We do discuss the importance of using include files to improve performance, but do not walk through the steps of identifying non-performant code.

4.6 Demonstrate ability to analyze and resolve security issues arising from site configuration and custom code

When it comes to writing secure code, we cover the most common mistakes and solutions. We dive into using string filtering functions, setting proper access control and working with the database securely. When it comes to configuration security, the most common problems that come into play are assigning the wrong permissions to your users. We go deep into how permissions and roles work, and what control each permission in Drupal core gives a user. We also explore some best practices in setting up roles.

Last week to get $75 off DrupalCon training

This is the last week to get $75 off of our super amazing DrupalCon Austin training. Our style of training guarantees that you'll emerge with valuable knowledge that you can put to practical use, regardless of your skill level. Students throughout the years have commented on how much they value the one-on-one interaction that they get with trainers, and how nice it is to have a training that lets you work at your own pace and allows you to focus on knowledge that is the most important to you.

Signing up for the training also wins you 4 months of free BuildAModule access, so if you're planning on being a BuildAModule member for the next 4 months and are coming to DrupalCon, it's a perfect fit. With the $75 off this week and the $119 worth of BuildAModule access, you'll be getting 40% off.

BuildAModule trainings are also a really good way to kick of networking at DrupalCon. One of the biggest things you'll take away from coming to DrupalCon are the connections to the people you meet. Because of our unique training format, you'll have the opportunity to meet lots of people - both trainers and fellow students - that could play a critical role in your learning or your businesses down the road.

And of course, it would be awesome to meet you in person and have the honor of helping you make a big leap up the Drupal learning curve. :-)

Read more about the training, or sign up now!

 

5 New Videos on Event Dispatching

This week we wrap up our brief whirlwind through PHPUnit and start looking at the Event Dispatcher component of Symfony. For Drupal Veterans, you'll recognize that it's similar to the hook system in Drupal, but with the benefits of Object Orientation.

Looking at how our test and assertion actually work, and where to find out which assertions we can use - 2:28

After spending a bit of time to really understand what PHPUnit is and get our tests wired up, we finally get a chance to look at the test we ran and watch it work. Woot!

Adding additional PHPUnit tests for our controller and 500 errors - 2:29

Well, we have one test working. Let’s add a couple more!

(FREE!) What the Event Dispatcher Symfony component does, and how to add it to our project - 2:29

In Drupal we have hooks that allow us to modify the path of processing for all kinds of things. We can adjust the content of forms, we can add pages to the menu system. In Symfony you can do the same thing with the Event Dispatcher component. In this video we talk briefly about what this component is all about.

How to add an event with the Event Dispatcher - 3:58

Before we can ‘listen’ for events, we have to set up an event. In this video, we create an event to allow us to modify the output of our pages before they get sent.

How to create an event class for our event - 2:18

It’s convention to create a class for each event to wrap around the variables passed to the event. Here we create that class.

How to install PHPUnit on a Mac or Linux - 2:25

In this video, we install PHPUnit - the tool we’ll use to run PHP unit tests - on a Mac.

How to install PHPUnit on a Windows machine, what PEAR is and how it compares with Packagist - 5:09

Here we install PHPUnit on Windows using the PEAR package manager, and we do a short showdown on what make Packagist a better solution for most scenarios.

How to set up PHPUnit configuration and set up our first unit tests - 2:40

Now that we have PHPUnit set up, we set up a configuration file to tell PHPUnit where to find tests.

How setting up interfaces for your classes helps with unit testing - 3:57

We’ve run into interfaces a couple of times so far (interfaces are like scaffolding for any child classes), and in this video we discuss the advantages of using interfaces for PHPUnit tests.

(FREE!) What dependency injection is, and updating our framework to use interfaces - 2:05

In this video we briefly talk about what dependency injection is and why it makes sense, particularly for testable code. We also update our code to use the interfaces we talked about in the previous video.

BuildAModule Mentored Trainings in New York, New Orleans and Chicago!

This last month Mentored Trainings were held before MidCamp in Chicago and the first ever DrupalCamp New Orleans, and this weekend there will be another to kick of DrupalCamp New York. From the feedback we've gotten for these and numerous Mentored Trainings over the years, they were an awesome way to jumpstart the camps. A couple quotes from MidCamp students:

"Class was very helpful and it's great to have so many experts in the room while trying to figure things out."

"I wasn't aware of BuildAModule and find it to have been a great resource. Thanks for a great experience and laid back format!"

Organizing a Mentored Training is actually pretty easy, and virtually anyone can do it. We've put together a set of resources on the Mentored Training page, and you can always contact us for more details. If you want to see first-hand just how amazing a Mentored Training can be, consider joining us at DrupalCon Austin coming up in June.

 

And 5 New Videos on Testing and PSR-0

How to add Composer autoloading for our custom code by making it PSR-0 compatible - 2:31

So far we’ve only used external libraries with Composer, but in this video we add the ability to be able to use the Composer autoloader with our own code. It’s super simple, will make your life easier, and instantly make your code reusable.

How to split up our leap year code into a controller class and a model class - 4:05

One of the principles of object orientation is that each class should have a single purpose. In this video, we restructure some of our code to use classes and put some of our leap year code into their own files.

Adding PSR-0 compatibility to our leap year code, and updating our app.php file - 2:33

In an earlier video, we saw how easy it was to add a PSR-0 folder to our autoloader, and here we do the same thing for our leap year code.

What unit testing is and how it can make your code better and more flexible - 1:43

Unit testing is a powerful and rapid way to automate testing and also insure your code is flexible enough to adapt to unanticipated situations. In this video we talk a bit about unit testing and its advantages.

(FREE!) The difference between unit testing, functional testing and regression testing - 3:11

If you haven’t really dived into testing your code, you may feel a little confused about the variety of tests out there. In this video, we clarify what the three most common ones you’ll run into are.

Registration for our highly-rated, practical and super fun training is now open! To register you or your team simply click here to add the training to your DrupalCon cart, or learn a bit more about the structure of the training here. If you want to make a huge leap up the Drupal learning curve AND get 4 months BuildAModule access for free AND get access to some amazing Drupal trainers for one-on-one help, this is the training for you.

If you are part of a Drupal team that has recently standardized on Drupal across your organization, this training will help your team mobilize in the right direction, so consider having your team do the training together.

If you have any questions at all about the training, just send them our way.

Ticket sales go fast, so be sure to grab them before it's too late!

And 5 New Videos on Having Multiple Front Controllers in Symfony

Updating our routes and controller to use the controller resolver, and how type hinting works - 2:59

After setting up our controller resolver, we update our routes to point to a method in our controller class and update our controller.

(FREE!) How we can use multiple front controllers for different environments - 2:11

In this video, we look at the code in our front controller and see that it would actually be pretty useful for other applications as well. This code could actually be the basis for a framework class. By moving our code out of our front controller, we make it simple enough so that we could have multiple front controllers without much duplicated code. If you’re not sure why that would be useful, watch the video to find out!

Creating a reusable Framework class - 2:55

Here we do the grunt work of pulling the code out of our front controller and into a new Framework class.

Simplifying our front controller while leveraging our Framework class - 0:53

One our framework class is in place, we update our front controller to use it, greatly simplifying the code.

One minute of reassurance - 0:57

At this point, we’re looking at a front controller that sets up half a dozen different classes that are all kind of abstract and only make sense in a certain context. In this video, I offer some reassurance that it took me a few times going through this to really understand it, and that much of what we’re covering is merely building up to the concept of why a framework is useful, and that some of these components you won’t need to use in your daily life.

Add to playlist

Add to , or

Add to new playlist:

Add to playlist
This is a member-only feature
But, it's easy to become a member

Add to cart:


Loading...
Contact us

Below are the supported keyboard shortcuts for our video player.

space
Start / stop video
shift
Go to next video
shift
Go to previous video
Increase or decrease player speed by 20%
Skip ahead or go back by 15 seconds
1...9
Jump to a percentage (2 is 20%, for example)
f
Toggle full screen
Videos Pricing More Search
BuildAModule Logo Icon BuildAModule Logo Icon
Become a member!
$29
1 month
$156
6 months
10% off
$276
12 months
20% off
All memberships come with the following:
24 / 7 access to the entire 1800+ video library
An innovative video player with a rolling transcript
Extensive Drupal and cross-platform training
A thorough and thoughtful training style
Progress tracking
Take notes on specific video sections
Intuitive multi-user management
How many users?
user
Go solo with a single user, or give multiple team members access through one account and get discounts by bundling multiple users into a single membership.