Feb 05 2019
Feb 05

As someone who has been building Drupal sites for over 12 years now, I'd like to think that my knowledge and expertise has grown at a rate similar to the power, flexibility, and complexity of the Drupal project itself. For well over 10 years, Drupal training and development has been the focus of my consulting business; over the holidays I took some time to look back and really think about the lessons I've learned and how I can utilize them moving forward. 

In addition to documenting the process for myself as well as my current and future clients, I also wanted to share what I've learned with the Drupal community. After all, it is this community that has made it possible for me to have the success that I have found so far. I have worked on projects of all sizes from large Fortune 500 companies to small local businesses. I’ve been alone on project as well as with large teams of developers. There have also been projects with massive budgets as well as projects with no budget. The breadth of this experience has really contributed to my ability to provide more value for my clients. 

One word I use often when speaking with current as well as prospective clients is "sustainability". I always want to be involved in a solution that provides good value not only now, but for the lifetime of the project. I want to build sites that are easy to maintain, easy to update, and easy for different developers to cycle in-and-out of. With sustainability, and all of the elements that contribute to it in mind, I present the 11 tips to start a Drupal project right. 

1. Commit to a Local->Dev-Stage->Prod developer workflow

Having a professional developer workflow should go without saying, but I often come on-board small, single-developer projects that have a remote development environment and a live environment - and nothing else. At the very least, projects of all sizes should have not only a dev and live environment, but developers should have local environments as well. 

There's a lot of focus on DevOps in the Drupal ecosystem (with good reason), but before you jump into a continuous integration/continuous development (CI/CD) system, be sure you have the basics first and then add complexity only as necessary. I've seen way too many projects invest in a full-on CI/CD system only to have it ignored because developers didn't have the time and/or expertise to utilize it properly.

2. Commit to the entire team using a project tracker

This is a bit of a pet-peeve of mine. I'm a firm believe that commitment to a project tracker must include 100% of the development team and stakeholders. Note the "and stakeholders" - this includes project managers, content and QA folks, and anyone else who has a role in the project. How often is a project ready to launch and then at the last minute a stakeholder chimes in requesting changes? This is demoralizing and frustrating for the entire development team.

Project tracker tasks should be focused. Large tasks like "theme the site" aren't very helpful and comment threads in tasks like this often become unwieldy, defeating the purpose of using a project tracker. Train the entire team on using the project tracker and committing to using it for the majority of project task communication. 

3. Utilize a remote Git repository

You're not using Git yet? Seriously? Stop reading this and go get yourself and your team trained up (we offer training). Also - commit early and often. Smaller, more focused commits (like project tasks) are easier to manage.

4. Use Composer to manage the code base

This is an article about Drupal 8, so this isn't really optional. While there is work in the community on various Composer-related projects, for now the Composer template for Drupal projects is the de-facto standard for managing your Drupal 8 project's codebase. Don't know how to use Composer? Learn it (we also offer Composer training).

5. Use consistent local development environments for development team

Avoid "it works on my machine" conversations for the rest of your life by ensuring that the entire development team is using identical local environment configurations. Docker-based solutions are tailor-made for this type of thing, but it has been possible for awhile with virtual machine-based solutions as well. A solid local development environment will pay dividends - making it easy to get new developers up-and-running, and allowing developers to focus on building the project, not monkeying around with their local environment.

I've been a fan of DDEV-Local, a Docker-based solution, for awhile - I provide training and I also wrote a book about it! 

6. Define information architecture with all stakeholders

This is where I see projects go sideways more often than not. When defining the information architecture (IA) for the site, all stakeholders must be involved. This tip really goes hand-in-hand with the next one, but the bottom line is that this needs to be a discussion. There's nothing worse than getting near the end of a project and showing it to a content author and finding out that there are gaps. Generally, the goal is to get the granularity right when defining IA. This is next to impossible to do without feedback early in the process from all stakeholders.

Review any existing content that is to be migrated to the new system, ask content authors what the issues with their current system are, and be careful not to over-engineer a solution that won't provide enough bang-for-the-buck. 

7. Prototype information architecture with content authors

This tip goes hand-in-hand with the previous one - an important part of defining the IA is testing and confirming that everything is accounted for. In my experience, the absolute best way to do this is by prototyping the system. Allow your actual content authors, editors, and admins to test-drive the new architecture by adding and editing content on a prototype of the site. This needs to be done very early in the development process, so the focus should be 100% on the add/edit forms - not the output. In fact, I recommend not putting any effort into theming the output at this point, making it crystal clear that the prototyping exercise is to confirm that the set of entities, bundles, and fields designs are on-target.

I really cannot stress enough how important this step is. IA mistakes made early that are not corrected will be a burden until they are corrected (if ever). It's normally relatively easy (and inexpensive) to fix IA mistakes early - quite the opposite if they are left to fester and other parts of the site are built upon them. I have never been part of a project where the IA prototyping didn't result in important updates to the IA. 

8. Create a style guide

If you're building a custom theme, then you probably need a style guide. Part of a solid UX/UI design is consistency in design. Consistency brings user comfort. When users are more comfortable on your site, they'll spend more time there. 

Style guides can be as simple or as complex as they need to be. At the absolute minimum, I would recommend that a style guide contain basic typography and a color palette. You'll need to consider how/if typography will change based on responsive mode (are H1s the same pixel size on mobile as they are on a desktop display?) Similarly, you'll want to think about how the header/navigation/footer respond to various screen widths as well. Have an element that appears throughout your site? Then define rules how it looks in various places and various screen widths. 

9. Create wireframes and mockups as necessary

Similarly, if your project is going to have a custom theme, then you're going to need to design the layout of key pages. How are landing pages arranged? How do they respond at various screen widths? Think about the entire site and design wireframes for a representative sample of pages. Only 2 or 3 wireframes are necessary for many projects (home page, content page, interior landing page). 

Consider these representative pages as a group, not individually. Look for common elements (easier to theme) and value consistency. If every page is a one-off, then implementation costs will rise. 

Start with wireframes and generate only the mockups you need. Often, between a solid style guide and some good wireframes, mockups aren't necessary in many cases. Think of the style guide as a box of LEGO bricks that can be assembled into mockups in various configurations. If time and budget is limited, favor the style guide over mockups.

10. Use the Configuration System

Drupal 8's configuration system provides a powerful tool to easily push non-code configuration changes between environments. The "trick" to using it is that the entire team has to understand and participate in the process. If the development team is five people, and only two are using the configuration system, you're going to have rough sledding. 

The configuration system will help enforce a solid developer workflow, encouraging team members to update and test configuration (like a new View) locally before pushing it to remote development environments. A byproduct of using the configuration system is that config changes can easily tracked by the project tracker via commit messages. 

11. Define realistic and meaningful milestones

There's not much that kills developer morale and confidence in a project more than lack of project leadership. At the core of this is often a lack of project planning and milestones. All team members should be involved in the setting of goals and milestones for the project. A single milestone of "the site must be done in 5 months" doesn't cut it. The entire team should work together to define realistic and meaningful milestones. Take into account non-project responsibilities of team members, identify and plan for potential pain points in the project. 

Project leaders need to listen to team members and provide training and professional guidance when necessary. Most developers are problem solvers who like to learn new things. Project leaders should embrace and leverage this for the betterment of their projects, the result will be a positive one for the entire team!

Mike Anello is the architect and instructor for DrupalEasy’s Drupal Career Online, which includes intensive live online sessions, rich learning resources, an active learning community and hands-on projects designed to provide those who need to get skilled up in Drupal with the best possible start. The next session of the DCO starts February 25th. If you’d like to learn more, you can sign up for a no-cost Taste of Drupal mini-webinar.

Jan 30 2019
Jan 30

All sorts of organizations have made their predictions and proclamations about what 2019 will be the year of... Some say it is the Year of Optimism and growth for helicopters, others, …of the Hack & Slash, …of indigenous languages, …of the electric SUV, and even the International Year of the Salmon.  It all comes down to what someone sees as an important aspect of their field to promote or what is or should be a trend.  DrupalEasy would therefore like propose we make 2019 the Year of Drupal Talent Development.

As an active member of the community, we've observed, had great discussions and provided several sessions at Camps and Cons about the talent shortage in the community as well as how to build a Drupal career. We feel it is pretty important to Drupal. Right now, there are more than 2,000 jobs requiring Drupal skills on Indeed, and hundreds more continually being added. The Drupal Association also recognized the need, as we discovered while putting together this blog post, with the introduction of a Drupal Educational Opportunities Newsletter, which will help get the word out to those looking to further their skills, and those looking to start a career in Drupal.  

As a training organization, we not only train within the community, but bring in new people to develop passion for Drupal. We’ve had over a decade to watch people who started out not being able to spell Drupal develop the commitment and skills to excel at it. We’ve seen our Drupal learning community grow, diversity, and expand internationally, as new students hone their skills and strive to contribute to the community while they do it. Through all of this talent development for Drupal and the community, most gratifying is seeing the companies and organizations compete for the people building rewarding and fulfilling careers through experience and participation. 

How can we make it the Year of Drupal Talent Development?  A simple way is for each of us to simply sharie information on Drupal as a career and the opportunities in Drupal to those who may benefit from it. For those with the need and resources, providing the education and training needed for individuals or teams. There are some great resources to get information about Drupal as a career

The US Department of Labor has an Occupational Outlook Handbookprovides summaries of careers including salary ranges, anticipated job growth, and types of work environments.  Their entry on Web Developer careers, though not specific to Drupal, seems to track pretty well. There is also great salary information about Drupal specific web development through the Indeed Salary Tool, as well as Glass Door's version

Of course, salary is just a part of it, so a few years ago, we put together a Drupal Career Resources page to provide an index of information, insight and news for those looking to get into Drupal. It is a quick way for those of us who are in the community to share a lot of information.    

We also truly believe that solid education in the ways of Drupal is key to get and keep people active in the community.  Mike Anello teaches our our 12-week live, Drupal Career Online course twice each year.  The career technical education course is licensed as a certificate program through the Florida Department of Education Commission for Independent Education.

Drupal Career Online is a  comprehensive program that includes 2 class sessions and one co-working lab session each week, along with Mike's office hours and access to other training provider resources, most recently Drupalize.me.  Participants are also provide rich learning resources including a lesson guide, class slides, links to go further in-depth into topics, and a screencast for every lesson, which is all accessible through a session-specific class web site. 

Prior to each DCO session, we hold Taste of Drupal mini-webinars to introduce people to Drupal, Drupal careers and our course.  There are 2 more sessions before the Spring 2019 session of Drupal Career Online kicks off on February 25th.  Those interested can sign up for a Taste of Drupal, or contact us to get more information.      

Dec 09 2018
Dec 09

If you've adopted a Composer-based Drupal 8 workflow (hopefully using the Drupal Composer/Drupal Project template) where you're keeping dependencies in your project's repository, then you've no-doubt experienced the annoyance of a rouge .git directory ending up in one of your project's dependencies. This will always happen when you're using the -dev version of a Drupal module. 

For example, as of the authoring of this Quicktip, the Field Redirection module does not yet have a stable release for Drupal 8. When added to a project using Composer, the results look like this:

Michaels-MacBook-Pro:dcoweek5 michael$ ddev composer require drupal/field_redirection
Executing [composer require drupal/field_redirection] at the project root (/var/www/html in the container, /Users/michael/sites/dcoweek5 on the host)
Using version 2.x-dev for drupal/field_redirection
./composer.json has been updated > DrupalProject\composer\ScriptHandler::checkComposerVersion
Loading composer repositories with package information
Updating dependencies (including require-dev)
Package operations: 1 install, 0 updates, 0 removals
  - Installing drupal/field_redirection (dev-2.x e1c30f2): Cloning e1c30f24f9 from cache
Writing lock file

Git directory

Notice on the "Installing drupal/field_redirection..." line, it indicates that the project is cloned, not downloaded. This means that a .git directory has been created in the Field Redirection directory.

Note that I'm calling Composer as "ddev composer ..." - this is because I use DDEV as my local development environment and am utilizing its built-in Composer command.

If this goes unnoticed, and you attempt to do a normal "git add/commit" workflow for the new module, you'll end up with a somewhat-friendly Git message indicating that you now have a Git submodule.

Unfortunately, Git submodules aren't normally necessary nor wanted when you are committing dependencies to the project repository. So, the typical solution is to delete the .git directory of the dependency prior to performing the "git add/commit".

Luckily, there's an easier way! Travis Neilans recently pointed me in the direction of the Composer Cleanup VCS Directories project. By adding this as a dependency of your project, any .git directories that result from adding project dependencies will be automatically removed! First, install the Composer Cleanup VCS Directories project using:

composer require topfloor/composer-cleanup-vcs-dirs

Then, anytime you use "composer require" to install a project dependency, if there's a .git directory, you'll see a message indicating that it has been automatically removed.

Deleting .git directory from /var/www/html/web/modules/contrib/field_redirection/.git

Nov 17 2018
Nov 17

Book: Local Web Development with DDEV ExplainedIt's no secret that I'm a fan of Drud Technology's DDEV-Local web development tool. I selected it as my local development tool of choice for both my clients and my Drupal Career Online students after an exhaustive search. I've been teaching monthly 2-hour online workshops getting folks up-and-running with DDEV, and I've taught numerous full day "Getting started with DDEV" workshops at various Drupal events around the United States.

Since I've been writing, testing, and refining curriculum related to DDEV for well over a year now, it made sense to take everything I've learned and put it in a format that makes it available to even more folks looking to easily adopt a professional local development environment. I'm super-happy to announce that the book is now available for purchase on amazon.com at a price designed to get it into as many hands as possible - just $5.99 for a digital copy and $9.99 for the dead tree edition.

This first book, Local Web Development with DDEV Explained, is the result of a partnership wtih Steve Burge and the rest of the fine folks at OSTraining, which is the publisher. They've allowed me to retain full control of the book while at the same time tapping into OSTraining's extensive experience in publishing and marketing books related to open source content management systems. 

The book covers the full range of topics related to local web development and DDEV. Topics covered include:

  • Why a professional local development environment is important.
  • What a professional local development workflow looks like.
  • Installing DDEV on Mac OS X, Windows 10, and Ubuntu.
  • Step-by-step example of starting a new Drupal 8 project with Composer and DDEV.
  • Step-by-step example of getting an existing Drupal project up-and-running with DDEV.
  • Adding a Solr container.
  • Common workflows using DDEV.
  • Extending DDEV with hooks.
  • Using Xdebug with DDEV and PhpStorm.

The bulk of the book's content is straight from my training curriculum, so you can be sure that it is tried-and-true, and, as always, reflects only best practices. My goal is always to teach the right way to accomplish a task - no hacks or shortcuts.

My goal is to update the book several times per year, with a list of topics for the first revision already growing. I'll be starting on it in the next few days! By purchasing a digital copy, you'll automatically get updates to the book as they're released. 

Sep 22 2018
Sep 22

Drupal 8's text format system provides a way for developers to manage user generated content, regardless of if the user is trusted staff member or an anonymous commenter. With intelligent configuration of various text formats for the various roles on the site, the security and usefulness of a site can be maximized.

Much like Drupal 7's Better Formats module, Drupal 8's Allowed Formats module allows a developer to limit the text formats that are available on the field level. Normally, all formats that the user has access to are available on all fields, this module allows developers to force a particular format to be applied on a particular field.

The configuration is available on all formatted fields' "edit" page. For example, take this configuration for a "short summary" field.

Allowed Formats example

In this example, only the "Minimal HTML" format will be available for this field, regardless of if the current user has permission to use any of the other formats. For this application, the "short summary" field can only have links, strong text, and emphasized text. By limiting authors to only the "Minimal HTML" text format for this field, these parameters can be easily enforced.

Sep 22 2018
Sep 22

Debugging a Drupal 8 module can take many forms. Often, one of the first tools most developers use is the ability to output variables using the "Devel Kint" module (part of the Devel project). Much like the dsm() function from pre-Drupal 8 versions of Drupal core, the ksm() function provided by Devel Kint provides a slick way to output any variable type to the screen in a readable way. 

Unfortunately, many folks find Kint output to be a bit more cumbersome, and they're right, but Kint is doing a whole lot more than dsm() ever did. In addition to outputting just the variable's values, if said variable is an object, then Kint also outputs that object's methods and other valuable debugging information. Unfortunately, all that information comes with a cost - it tends to really bog down web browsers.

I was finding that some large variables in Drupal core ($form and $node, I'm looking at you) could even crash my browser (out of memory) due to the sheer depth of information returned by a simple ksm(). Out of desperation, I searched for a way to tame Kint a bit so that I could go about my debugging business.

Luckily, I stumbled upon this gist by Julian Pustkuchen which demonstrated how to limit the number of levels returned by a ksm() call. This solved my problem - no more browser out-of-memory issues. The downside is that sometimes a ksm($form) call doesn't get me deep enough into the array, so I have to be a bit more specific when ksm-ing. 

I took Julian's gist and dropped it in my settings.local.php file as follows:

include_once(DRUPAL_ROOT . '/modules/contrib/devel/kint/kint/Kint.class.php');
if(class_exists('Kint')){
  // Set the maxlevels to prevent out-of-memory. Currently there doesn't seem to be a cleaner way to set this:
  Kint::$maxLevels = 4;
}
Sep 22 2018
Sep 22

I've been a big fan of Drupal 8's configuration system since the beta-days of Drupal 8, and even more so now as the contributed module ecosystem around it has matured. I've been using the Config Readonly module from the very beginning to "lock down" configuration on production environments in order to help enforce developer workflows. 

Using the Config Readonly module is a bit of a double-edged sword. On one hand, it really helps in helping get developers accustomed to making configuration changes on local, then exporting them using Drupal 8's configuration system, committing them to the repository, and then moving them up through the project's defined deployment workflow.

On the other hand, sometimes it just really gets in the way. Two areas where I find that clients really find Config Readonly annoying in the live environment is when configuring menu items and block placement, both which can be affected by locked-down configuration. When the Config Readonly module is active, it is not possible to drag-and-drop menu links to reorder them. Nor is it possible to place a block or move a block to a new location.  

Luckily, the Config Readonly module maintainers added the ability to "whitelist" some configurations in version 8.x-1.0-beta3. This allows developers to keep certain configurations "unlocked" on the live environment via the settings.php file. For example:

if (IS_LIVE_ENVIRONMENT) {
  $settings['config_readonly'] = TRUE;
  $settings['config_readonly_whitelist_patterns'] = [
    'page_manager.page_variant.*',
    'system.menu.main',
  ];
}

In this code snippet, all Panel page variant configuration as well as the main menu are whitelisted, allowing site authors to modify these aspects of the site directly on the live environment.

Sep 22 2018
Sep 22

I ran across a situation the other day that had me a bit frustrated for a few minutes until Ted Bowman nudged me in the right direction. I was working on a small custom module for a client - one that involved altering a node form using hook_form_alter() - where I needed to know the value of the node ID being edited.

I had spent more than a few minutes digging into both the $form array and $form_state object desperately looking for the node ID, to no avail. I had pinged Ted on Slack about something else and I asked him if he knew how to find what I was looking for - he told me "maybe the form object is better".

That's all I needed to get unstuck, a few minutes and a Google search or two later, I stumbled upon the following:

$form_state->getformObject()->getEntity()->id()

Not only would this return the node id, it will actually return the id for any type of entity.

Just to be safe, I went ahead and wrapped it in a if-statement to make sure that the form object returned is actually an entity form:

if ($form_state->getFormObject() instanceOf EntityFormInterface) {
  $nid = $form_state->getformObject()->getEntity()->id();
}
Aug 13 2018
Aug 13

Drupal Career Online Case Study: Rosewood Marketing

Like their arboreal namesake, Rosewood Marketing is amazingly sound and particularly suited for very specific applications. Where the Rosewood tree serves to form the structure of certain fine musical instruments, billiard cues and chess pieces, Rosewood Marketing serves as a bridge for dozens of Amish and Mennonite small businesses to mainstream society. Their growth and development over the 22-year span of their success is not just in their marketing prowess, but in their inherent, sincere understanding of their client culture.    

If you really think about it, Rosewood has perhaps one of the most focused and secluded market segments in the US, which interestingly enough allows them to bring a type of diversity to the Drupal Community we don’t often consider. They do this amazingly well in their approach to business development and hiring. They first truly match new employees to their market and their company culture, and then leverage training programs to ensure the team has the skills and best practices in technology and communications to meet their business standards.  A person hired as a graphic designer receives training in tools such as Photoshop, InDesign, design principles and customer service. An online marketer receives training in analytics, SEO, and PPC, while a new manager learns time management.

Others become web developers, and as our luck would have it, DrupalEasy students and graduates. Of Rosewood’s 16 member staff, two are Drupal Career Online graduates and one new hire has just been enrolled in the upcoming Fall 2018 session.  Our new Rosewood student already has experience in Drupal 7, but needs to move forward in Drupal 8. Adrian Nolt, a 4-year employee of Rosewood and a Fall 2017 DCO graduate, explains, “Even though Stephen has...Drupal site-building experience, I recommended that he take DCO in order to acquire a common training foundation as our other Drupal developers...For me as a primarily self-taught Drupalist, DCO filled in knowledge gaps, and I would like for Stephen to experience the same joy.”

Stephen Ebersole, who was hired recently, works remotely for Rosewood, with his primary residence in Georgia, and currently living in Honduras serving his church. He, like most Rosewood employees, is a member of a Mennonite community.  Adrian explains, “Since Rosewood's target market is businesses run by members of the Plain Communities...besides the native understanding of our target market, we feel that while Drupal may be hard to learn, it is easier to pick up than people skills and a solid work ethic.”  

Adrian highlights the importance of this native understanding by explaining, “Many members of the Plain Communities are devout Christians with strong convictions...If a Rosewood team member does not...appreciate why his or her client will, for example, give up internet access in order to free himself from unnecessary temptations, he or she will not be able to make recommendations that align with our client's values. This understanding is more important to our ability to serve our clients well than expertise in a specific technology.”

Adrian continues, “...as soon as an employee has sufficient proficiency to perform basic tasks, he or she begins working on paid work, even if it means billing our clients at a reduced shop rate for a time. We believe that learning by doing is one of the most efficient ways to learn..though... can leave holes in a person's knowledge. For some of us, taking DrupalEasy's DCO course is about filling in the gaps and providing a common foundation for working together. However, it is also one of the fastest ways I know to get a Drupal beginner up to speed and productive with Drupal.”

The team at Rosewood has used video courses, but they have found for their purposes,  says Adrian, that “...many are too basic or not opinionated enough to apply to most real-life Drupal development practices.” He continues, “For example, they may teach installing Drupal 8 from a tarball, but we had already committed to a composer-driven workflow for Drupal 8 as the safest long-term bet, and I was looking for a course that teaches a professional development workflow. DrupalEasy DCO has proven to be the well-rounded, just-deep-enough training we were looking for, and as long as Drupal remains one of our specialties, we expect to consider it as part of our Drupal training regimen.”

Adrian feels the most valuable aspects of the DCO include clarifying the intersections of fields, blocks, entity types, content types, and relationships, which he says can be an "ah-ha" moment to someone just getting started. He also appreciates becoming familiar with command-line, git, local development, and views, as it is a must for success in Drupal 8, which he feels is a huge hurdle for those getting started. He adds “...the value of DCO lies in how it connects all the pieces, such as workflow, data architecture, module development, theming, and the business of Drupal, together into one comprehensive introduction to the Drupal ecosystem.”

Rosewood’s clients are primarily in the agricultural industry, or are builders, retailers, craftsmen, and small manufacturers, including small businesses such as  Vierbike, MM Weaver and Blue Ridge Furniture. The company is now going with other CMS options for simpler sites, but Adrian emphasizes,  “Drupal continues to excel at use cases that require structured data and over 30 pages. We feel that having Drupal in our tool bag allows us to provide outside-the-box marketing solutions to our clients simply by combining modules and configuring the user interface. On other platforms, competitors may need to resort to custom code or make compromises in order to use an out-of-the-box solution.”

As far as their training philosophy, that is evolving as well, according to Adrian, “In the past, we prescribed training when a person was hired or when they needed to learn something new. However, we have begun budgeting training dollars and time into our annual budgets in order to continually grow as professionals and as a company.” He continues, “Hiring and training people is a way to scale our service-based business to serve more clients. Continued education adds to our in-house skill set to allow us to serve them in more ways and more efficiently. Happy clients = successful Rosewood.” He adds, “We don't know the future, but judging by the past, we will continue to hire and train employees.”

The Fall 2018 session of Drupal Career Online starts September 3rd.  Group rates and government discounts are available. If you‘d like more information, join us for our no-cost mini-webinar Taste of Drupal on Monday, August 27.  

Jul 22 2018
Jul 22

A Drupal Career Online Case Study

Lisa StreeterA lack of off-the-shelf eCommerce software products that could meet the unique needs of her family’s biotech manufacturing company was a real issue for Lisa Streeter. “We’re not a big enough company to afford large, custom database solutions, so we needed to figure out how to do everything in-house,” she explains. (Lisa’s work responsibilities included everything computer-related, and “some other stuff.”) That’s how it started, but instead of just a solution, Lisa Streeter wound up with a whole new, fulfilling career.

Her initial quest for a database solution quickly began to grow her fascination in web development (primarily eCommerce,) and lessen her interest in the family business. “I like the idea that in web development, you’re actually building something, architecting information rather than just analyzing it,” she explains. She fine-tuned her focus, and after discovering Drupal, began to seek an effective way to become proficient.

“I don’t remember exactly how I first learned about Drupal Career Online. I didn’t know anybody who did anything with Drupal, so in the beginning I was just trying to figure out how I could learn Drupal," she explained. She tried some self-teaching methods, but those were not providing her a clear and effective path forward. DrupalEasy was regularly popping up in Google searches and referenced on sites like Drupal.org. “Early on it made my short list of potential “good places to learn Drupal” and then it was just a matter of finding the right time,” she recalls.

It turned out the time was the Fall 2017 session, and according to Lisa, that’s when her interest took a fast track, “I started really getting Drupal. It was a transformative experience.” She dove into the curriculum, participated in class, and DrupalEasy matched her with Matt Glaman from Commerce Guys as her mentor.  From there, her path became clear and direct. “DCO was just the right level of time commitment and intensity for me. It demanded enough of my time and effort to really accelerate the pace of my Drupal learning,” she explained. “At the same time, while I needed to give the class my full attention, it didn’t completely take over my life like going back to school full time would have,” she added.

Lisa has far exceeded our expectations as a developer hired with no previous Drupal experience. The discipline and experience she developed as a PHP developer transferred directly to Drupal development under the tutelage of DrupalEasy, and she's already making a huge impact in our team and community.

-Ryan Szrama, Commerce Guys

The online, live instruction by an expert in Drupal and training was a great fit for Lisa. “Mike is an exceptional teacher who helped me really “get” what Drupal is all about, how to do things and think about solving problems in the “Drupal way.” This was something I wasn’t able to learn on my own from books, screencasts, or trial-and-error,” she recalled.  She also appreciates the small class size and Mike’s personal commitment to everyone enrolled. She explained, his “personal interest in getting to know every student individually made the class seem tailor-made for me, even as I could see that it was also meeting the needs of my classmates in different ways,” she continued.

Mike Anello, (@ultimike) has been a part of the Drupal project for more than 12 years, and developed and has been delivering Drupal career training since 2011 via live in-person and online sessions and contracted programs with organizations needing to train their development teams in Drupal. His curriculum has become the model for the development of several other long-form training programs. He keeps alumni connected and engaged in learning through the DrupalEasy learning community, which evolved from his weekly online office lab hours. According to Lisa, “When you take the DCO course, you definitely feel like Mike is personally invested in the success of each and every student.”

With her interest in eCommerce in mind, Mike connected her with mentor Matt Glaman, a Drupal project maintainer and one of the Commerce Guys.  “For me, this resulted in a perfectly matched mentor, one who challenged me to tackle harder problems than I would have thought possible,” she said.  Matt recognized Lisa’s passion and talent, shared his insights with Commerce Guys partner Ryan Szrama, and then according to Lisa, “It all happened pretty quickly! “ The DCO ended just before Christmas, and she was offered a position on January 16th.

This fast track is a result of Lisa’s passion and Commerce Guys confidence in her abilities and training. She explained, “Ryan decided that he’d rather not hire me as a “Junior Developer”, even though there was an expectation that I’d be learning and working to improve my Drupal skills. Instead, I was hired as a “Drupal Developer,” with the understanding that I’d take responsibility for my own progress.”  It appears she has done just that, since in addition to serving as a developer, she recently was given the opportunity to be “Documentation Lead” (in addition to continuing dev work.)

Six months into her new career, Lisa is clearly fulfilled.  She recounts, “Before I started at Commerce Guys, I was worried about whether I could really handle a real, professional job (working for someone other than my family) while also being a stay-at-home mom.  But Commerce Guys has been a perfect fit in that respect. Many of my coworkers also have young children - everybody at Commerce Guys has been very gracious and understanding about my time.”

Commerce Guys is equally thrilled with Lisa. According to Ryan, "Lisa has far exceeded our expectations as a developer hired with no previous Drupal experience. The discipline and experience she developed as a PHP developer transferred directly to Drupal development under the tutelage of DrupalEasy, and she's already making a huge impact in our team and community."  Commerce Guys is still in hiring mode, looking for "...people who align with our company's core values and core focus. We value making an impact, taking initiative, and serving our customers with integrity. We focus on solving hard problems (our passion) within the eCommerce space (our niche,)" Ryan added.  

In addition to her documentation responsibilities, Lisa is currently doing site building, writing custom code and site administration. She also works on Drupal Commerce and related contrib module issues. “I write patches, including automated test code. Someone from the team reviews my code and gives me helpful feedback, which is also a really great way to learn and improve my coding skills, with the bonus that I’m directly contributing to the Drupal community,” she explains.

“The best part about my new career is that I have a “career.” For years, I’ve had an ambiguously defined job at my family’s company. I didn’t report to anybody, and nobody reported to me; I just “fixed” lots of random problems...I had to invent my own job title. So being able to say now that, “I’m a web developer” is pretty awesome!  

She also loves being part of a team, she explains “After so many years of working independently, it’s great to have job that involves a lot of collaboration, especially when the people I work with are so talented. And being part of the Commerce Guys, an organization that strives to make an impact with the software it creates, I have a sense of greater purpose.”

Even with all of her success, she highlights that she is still learning.  “In DCO, Mike talked about how he’s continually working to improve his own skills and how that’s something you need to enjoy doing to succeed as a web developer. I’m finding that to certainly be true for me. It’s just a really good feeling to be able to look back a month or 6 months and see how much I’ve learned and improved since then,” she explains.

The next session of Drupal Career Online starts September 3. Learn more at an upcoming Taste of Drupal free mini webinar, and check out our career resources for information on web developer and Drupal-specific careers. 

Jul 04 2018
Jul 04

Quote: Great hands on intro...We're happy to announce that we've partnered with the folks at DRUD Tech to create and deliver a live, online, hands-on workshop that will teach the basics of professional local Drupal development using DDEV-Local.

DDEV-Local is a Docker-based local development environment that is designed to get your projects up-and-running quickly on your local development machine. DDEV-Local can be used with Drupal 7 and 8 as well as WordPress and other content management systems.

One of the big advantages of using this type of local development environment (as opposed to an old-school WAMP/MAMP-type solution) is that DDEV helps to ensure that every member of the development teams is using the exact same development environment, increasing productivity and decreasing the chances of environment specific bugs. Furthermore, you'll find that getting team projects up-and-running on your local machine is super-fast!

If you've been reading our recent blog posts or listening to our podcast, then you probably already know that we've taken a keen interest in local development environments lately. 

In fact, we've been diving deep into local development environments for almost a full year now, as we're in the process of evolving our long-form training classes to teach and utilize a more professional local development environment solution. A couple of months ago, we decided to standardize our trainings on DDEV, and since then we've been talking with the DRUD Tech folks (the creators of DDEV) about putting together a workshop that will provide students what they need to get up-and-running with DDEV-Local.

Here's a quick overview of what this new workshop will cover:

  • What is DDEV? 
  • Installing DDEV-Local (Mac OS X and Windows 10 Pro)
  • Getting an existing project up-and-running in DDEV-Local
  • Everyday DDEV-Local commands and functionality
  • DDEV-Local integration with hosting providers  
  • Updating DDEV-Local
  • DDEV-Local Tips and Tricks
  • Getting help with DDEV-Local

The first workshop will take place on Wednesday, July 18, 2018, 1-3pm EDT, and the cost is $75. Following the completion of the workshop, you'll have access to the 20+ page curriculum PDF as well as more than 10 screencasts demonstrating installation and basic usage of DDEV-Local. 

Register today and start using a professional local development environment!

We’ll be running the workshop monthly, so If you can't make it on July 18, upcoming dates include: 

  • Wednesday, August 22, 2018, 10am-noon EDT
  • Wednesday, September 19, 2018, 9-11am EDT

Quotes on this page were shared by participants in our beta-test of the course

Quote: Mike consistently ensures...
 

May 27 2018
May 27

This summer, we're taking the all-new "Upgrading your local development environment with DDEV" lesson from our 12-week Drupal Career Online class and bringing it with us as we visit three different Drupal events around the USA. At each event, we'll be presenting it as a full-day workshop at no- or (very) low-cost to event attendees.

Twin Cities Drupal Camp, Asheville Drupal Camp, Colorado DrupalCamp logos

If you're looking to move your local development environment to a more modern solution, then we believe this workshop is exactly what you're looking for. DDEV is a Docker-based environment built on modern principles and designed to be flexible, customizable, and powerful. 

We have been using DDEV with our current Drupal Career Online students, and are confident that our workshop is providing the skills they need to use it as their day-to-day local environment. The workshop (and DDEV) is designed for developers on Mac OS X and Windows 10 Pro - at the end of the day, you'll have the confidence you need to make the switch.

In addition to the full-day of training, you'll also leave with access to our 20+ page workshop handout (PDF) as well as access to all of our DDEV-related screencasts.

So, if you're interested in making the change, be sure to sign up for one of our in-person workshops this summer!

May 19 2018
May 19

Have you ever been building a form and found yourself wishing that you could insert additional help text - or even other forms of content (images, video) inline with the form? While each field's "Description" field is useful, sometimes it isn't enough.

The Markup module solves this problem in an elegant way by providing a new "Markup" field type.

Markup field type

This field doesn't expose any input widgets to the end user, rather it just allows for site builders to add additional markup (content) to an entity form.

Editing a Markup field.

The markup isn't saved with the resulting entity - it's just there to provide additional information to the user filling out the form.

Granted, this has always been possible by writing a small custom module utilizing hook_form_alter(), but having it as a field type makes it much more convenient to use.

Apr 23 2018
Apr 23

With Drupal 8, the use of view modes (both default and custom) is gaining momentum. This is especially true because of their ability to be easily utilized by Views. Rather than specifying a list of fields with all the required configuration in a View configuration, many site-builders are finding it much easier to define a set of view modes for their entities, have them themed once, then re-used throughout the site - including as part of a View's output via the "Show: Content" option in a View's "Format" configuration. 

One hiccup that can slow this down is the not-uncommon occurrence of when a field needs to be output as a link to some destination. While this is relatively easy to do with Views' "Rewrite fields" options, there isn't an obvious solution when using view modes.

Enter the Linked Field module. As its name implies, it provides the ability for any field to be output as a link via its formatter settings. The formatter can be configured with a custom URL or it can use the value of a URL from another field value.

Linked Field module formatter settings

Think of this module as an "Output this field as a custom link" option for view modes!

The "Advanced" configuration section for the formatter settings includes the ability to custom things like the title, target, and class attributes for each link. 

If your goal is to maximize the use of display modes throughout your site, then this contributed module is an important tool in your arsenal.  

Mar 20 2018
Mar 20

Over the past year or so, I've been looking to replace my standard local development environment with a Docker-based solution. I've been evaluating DDEV, Docksal, and Lando (listed alphabetically), trying to figure out not only was the best for me, but also the best for me to teach and recommend to the hundreds of folks I teach both long-form and full-day Drupal workshops to each year. As I've test-driven each of these three options, I've been periodically posting tutorials on various related topics.

DDEVAs a long-time Mac OS X user, my previous go-to local development stack has been a mix of MAMP Pro and Acquia Dev Desktop. For teaching, I've mainly been recommending Acquia Dev Desktop, but I think the time has come for a more flexible and professional-level solution. The ability to customize each project's development environment with various versions of PHP, different database and search index servers (adding a Solr server to any of the options in this article is just plain easy), and other things is too big of an opportunity to let pass.

My evaluation of DDEV, Docksal, and Lando has not been quick. I've been using Docksal for several client projects for well over a year now. In fact, during the initial Mastering Professional Drupal Development Workflows with Pantheon course, I recommended it to all of our students. I've even written and shared a somewhat Pantheon-flavored version of a Docksal configuration. It includes custom scripts for automatically downloading and importing a copy of a remote Pantheon database to the local environment as well as running some initial Drush commands after the import is complete.

As the Lando project matured, I was attracted to it mainly for its recipe-based configuration, including a Pantheon-flavored recipe that outdid my custom Docksal scripts. Currently, I'm using Lando for about 5 different client projects (as well as my local development environment for DrupalEasy.com).

Finally, a few months ago, I saw down with a few folks from the DDEV project at BADCamp for an extended walkthrough. It took me another month or two before I really dove into it, using it for a new client project, but at this point (spoiler alert), I'm leaning towards it being my go-to local development environment for teaching.

Comparison

What follows below is just a summary of the various features that I've focused on while test-driving each option. By no means it is a comprehensive list of features, but I think it is safe to say that these are what are most important in my use cases. As I mentioned above, my needs are twofold: a solid local development environment for client work, and an easy-to-install-and-configure local development environment for my students on both Windows and Mac OS X. I imagine that most folks don't have the latter requirement, so be sure to select the best environment for your needs.

In no particular order, here's what I focused on:

User interface

All three options are only command-line driven at this point; none have a graphical user interface (yet). All three options provide a command-line tool with different (but similar) commands. For example:

  • To start a project's containers: lando start, fin start, ddev start ("fin" is Docksal's command-line tool)

  • To stop a project's containers: lando stop, fin stop, ddev stop

As Lando evolved from Kalabox, there is talk that a GUI may be part of a paid add-on in the future. The DDEV team has also made it known that a GUI is in currently being developed.

Hard drive space

As all three options are Docker-based; each project on your local has its own set of containers. I've found that for a typical project, these containers require (I think) around 500(ish)MB of hard drive space (not including your project's data). Obviously, this can add up quickly depending on the number of projects you have on your local. I've found that DDEV has an advantage in this area, as it stores your project's data (database, files directory) in a directory shared with the host operating system - so you can remove a project's containers without losing your site's data (database) - thus saving hard drive space. For someone like me who creates a lot of sites (for teaching), this is non-trivial. DDEV's "ddev remove" command that removes only the containers. If you want to remove a project's data as well, "ddev remove --remove-data" does the trick. Both Lando and Docksal have commands to remove a project's containers and data as well, but neither (currently) has an option to preserve data.

LandoAs someone who had zero knowledge/experience with Docker at the beginning of this process, estimating how much hard drive space this stuff takes up is a bit of a black art. The "500(ish)MB" number I mentioned in the previous paragraph isn't anything more than an estimate as I watch my available hard drive space grow and shrink as I create and remove sites. I would love to have easy-to-use commands (for someone that isn't familiar with Docker) showing how much space is being used, options for clearing Docker caches, and anything else that could help developers manage hard drive space.

Drush and Drupal Console support

DDEV, Docksal, and Lando's command line tool provide a command to run Drush commands: fin drush <drush-command>, lando drush <drush-command>, ddev exec <drush-command>.

Pantheon and other remote host support

I tend to use Pantheon quite a bit, both for clients and teaching. The ability to easily get a local environment's database up-to-date from a remote environment quickly is a huge time-saver (and solid development practice). Having integration with Pantheon (and hopefully other hosts in the future) is an important factor for me.

  • DDEV's Pantheon integration isn't as complete, but it does have the valuable "pull" command which will bring down the database and files directory. I really wish it had separate commands for pulling the database and files directory. Often, it only makes sense to only pull the database, and then use something like Stage File Proxy for local files.

  • Docksal lags behind in this area - it don't provide any built-in tools for interacting with remote hosts, but they do provide useful examples for creating your own custom commands.

  • Lando has the edge here, with its robust push-and-pull commands for moving databases, files directories, and codebases between your local and any remote Pantheon environment.

Pre-made configurations

  • DDEV has various "quickstarts", similar to Lando's recipes, including ones for Drupal 6, 7, and 8, as well as Backdrop, Wordpress, and Pantheon hosting.

  • Docksal provides some basic default stack configurations, including an Acquia Cloud one, but not on the same level as Lando or DDEV. UPDATE: I've been corrected - Docksal does example configurations available for Drupal 7, Drupal 8, WordPress, and a few other CMSs.

  • Lando provides local development environment "recipes" for a plethora of development projects - including recipes for Drupal 6, 7, and 8, as well as recipes for Pantheon, Python, Dotnet, Joomla, Wordpress, and several other commonly used frameworks and providers (it is really quite impressive).

It doesn't appear that any of the options support Acquia, Platform.sh, or any of the other so-called "modern" Drupal hosting solutions (yet), but I don't think there's anything stopping that from happening in the future. In fact, it is already starting to happen.

Support and Documentation

All three options have both issue queue support as well as real-time chat support. Your mileage may vary, but I've found all three projects have very responsive maintainers, with a slight edge going to DDEV for responsiveness.

In addition, they all have relatively good documentation, considering their rapid development schedules and frequent additions. With all three options, I've found that I've had to hunt down answers not easily found in the documentation.

As an example, a few times while creating a new DDEV-powered site, I kept getting a message that port 443 was in use, but I couldn't figure out by what. It was easy enough to change the DDEV config to use a different port number, but it wasn't until I stumbled on a blog post where I learned about "lando poweroff" - this command spins down all Lando containers, including a "traefik" container that holds on to - you guessed it - ports 80 and 443. While there is a documentation page for "lando poweroff", there's nothing on the "Getting started" documentation page about it. It was only by searching the web and finding a blog post that I was able to figure out what the root cause of the issue was. I'm not picking on Lando here (far from it), as I've run into similar documentation issues with DDEV and Docksal as well. Bottom line - use all the support resources available to you.

Frequency of updates

One measure of a project's health and momentum is the frequency of updates. In all three cases, development is clearly on-going in each project.

  • DDEV - 6 releases in 2018 (5 minor, 1 patch), 13 releases in 2017 (10 minor, 3 patch).  

  • Docksal - 0 releases in 2018, 11 releases in 2017 (1 major, 6 minor, 1 patch).  

  • Lando - 4 releases in 2018 (4 betas), 51 releases in 2017 (20 alphas, 31 betas).  

Windows support

While I'm a Mac OS X user, not all of my students always are. Therefore, it is important to me that I select a tool that works well on both Mac and Windows, with a minimum of any "unique configurations" on Windows. All three options utilize some form of automated testing to ensure that each build works on both platforms. To date, I haven't discovered any major issues with any of these tools on Windows. In all cases, I've found it to be much easier to use a 3rd-party command line emulator, rather than using Windows' default command line tools.  

Requires internet connection

  • DDEV works fine without an internet connection - no configuration necessary.

  • Docksal can be run without an internet connection by manually adding an entry to your hosts file via the "fin hosts add mysite.docksal" command.

  • Lando has a documentation page about offline development, but it is only for Mac OS X, and the process is a bit more involved. UPDATE! I goofed! The previous link is if you want to manage your own local DNS, if you just want to work offline, it is much easier!

PHP options

All three tools provide the ability to swap in different versions of PHP via their configuration files.

  • Docksal allows you to place a partial php.ini file as part of your project's configuration. The directives in this file will override any default PHP settings provided by the container.

  • Lando has some support for some PHP settings as part of their configuration files and also supports a php.ini file as part of a project's configuration.

In all three tools, it is possible to ssh into the CLI container and modify the php.ini settings directly - using this approach, these changes are only temporary, however, as the next time the container is rebuilt, the custom php.ini changes will be lost.

Performance

DocksalWhile I didn't run a full suite of tests on all three options, I did want to quantify their relative speed in a real-world situation. My method was to take an actual (Drupal 8) client site, get it up-and-running in all three options (sequentially), and simply time how long it took to run a "drush cache-rebuild all". I ran the command three times for each option and then calculated the average. Other factors depending on your exact site and configuration may come into play (having Xdebug enabled is a bit of a performance hit), so your mileage may vary.

  • DDEV: 90 seconds
  • Docksal: 20 seconds  
  • Lando: 89 seconds  

Why the huge advantage for Docksal? It's pretty simple - I'm currently using Docksal in "virtual machine" mode instead of utilizing Docker for Mac (both Lando and DDEV utilize Docker for Mac/Windows). It's pretty well-known that native Docker for Mac/Windows solutions are a bit performance-challenged. According to Docksal documentation, Docker for Mac/Windows will eventually become the recommended way of working with Docksal, despite the performance losses.

Other stuff

  • Docksal has a cool "automatic stand-alone CLI container" - this is a container that is not tied to a specific project and is always available. One big advantage to this container is that it can be used to run Composer commands without having to have Composer installed on the host operating system. This is (IMHO) a big deal on Windows, where installing Composer can be tricky (due to its dependency on PHP). There is talk for doing something similar in Lando as well as DDEV.  

  • Docksal utilizes a separate command to start and stop its main virtual machine (fin vm start/stop). It's not a big deal, just a small extra step (but the performance gains are worth it, as mentioned above.)

  • DDEV automatically writes a settings.local.php file, overwriting the entire file. So, if you're like me and you like to have configuration settings specific to your local environment (Stage File Proxy, Environment Indicator, as well as some of the stuff found in example.settings.local.php, you'll have to either recreate your settings whenever DDEV overwrites the file, or you can create a second settings.local2.php file. There is an open issue about possibly modifying this behavior.

Summary

Things I love about each option

  • DDEV - the fact that I can completely remove a project's containers without losing the project's database (and other data) is really nice. While their Pantheon integration isn't as robust as Lando's, it does enough (for now). The team behind DDEV appears to have the most consistent release schedule, and I've found their various support channels to be the most responsive. Also - DDEV has a "ddev sequelpro" command that automatically launches the Sequel Pro app (Mac OS X) and connects to the current project's database. I know it's a trivial thing, but I love it so much.

  • Docksal - its fast. If/when the maintainers decide to make using Docker for Mac/Windows the default, it'll be back on even ground with DDEV and Lando, but for now, it's just plain fast. I also really like that Docksal includes a "fin run-cli" command that allows you to run Composer commands ("composer create-project", for example) before setting up a project's containers. So handy.

  • Lando - its Pantheon integration is second-to-none. The ability to push and pull code, database, and/or files makes it a breeze when integrating with Pantheon sites. I'm really looking forward to when additional hosting-based recipes are available.

Things I don't love about each option

  • DDEV - I use a MacBook Air with 8GB RAM and a 1.7GHz Intel Core i7 as my main development machine. The stunning performance gap between DDEV and Lando compared with Docksal is completely attributed to Docker for Mac. I don't know all the ins-and-outs about why its performance is so lame, but I find it maddening sometimes. Also, the settings.local.php issue I mentioned above, but fingers-crossed that gets resolved soon.

  • Lando - re-read what I just wrote about DDEV (except for the settings.local.php stuff). Same. Also, whenever Docker is restarted, the Lando proxy also automatically starts up and grabs hold of port 443 - regardless of if I have any local Lando sites up-and-running. This can cause conflicts with other processes that want to use that port. Lando's "push" command for Pantheon is a little too aggressive for my tastes - it automatically adds, commits and pushes all outstanding changes in your local codebase to the Pantheon repository (I don't care for "git add ." either).

  • Docksal - lack of Pantheon integration. Granted, it's not terribly difficult to write custom commands to automate pulling databases from Pantheon, but it sure would be nice if it was built-in.

While going through this exercise, I've realized that there's really no single globally "the best" solution. There are pros and cons for each option, and it's really up to the developer (or development team) to determine what's best for them.

Regardless of which option you decide to go with, here are some important things that I've learned:

  • Pay attention to updates and apply them appropriately (including Docker updates if you're using DDEV or Lando). The pace of each option is such that something that doesn't work today might very well be fixed in the very near future. Pay attention to the release notes for each update, as sometimes there are incompatibilities with specific versions of Docker.

  • All of these options take up a non-trivial amount hard drive space for each project. For projects that are dormant, go ahead and destroy the containers - that's the whole point of having a solid developer workflow. Recreate the containers (re-import the DB and files directory if you're using Lando or Docksal) when you need to work on the project again.

  • Get familiar with the real-time chat support for whichever option you go with. They can be real time-savers.

Which will I be using going forward? For client work, the answer is "probably all three". For more complex sites, I'm addicted to Docksal's performance. For teaching, I'll be test-driving standardizing on DDEV starting with the Spring, 2018 class of Drupal Career Online. It's ease of installation on both Windows and Mac OS X, along with its straightforward commands, hard-drive-space-saving architecture, and incredibly responsive support channels give it the edge (at least for me) over Lando.

Which solution should you use? It really depends on you and/or your team's situation. You're going to want to take into account factors such as host operating system (Mac OS X or Windows), hosting environment (on-site, managed VPS, Acquia/Pantheon/Platform.sh), skill level, and other factors. We're experiencing a bit of a renaissance in local development environments with a good deal of innovation and momentum - which makes it a buyer's market, so take advantage and find the solution that works best for you.

Official project links

Blog posts

Acknowledgements

Thanks to Mike Pirog from the Lando project, Rick Manelius from the DDEV project, and David Hernandez from the Docksal project for their input on this blog post.

Mar 04 2018
Mar 04

DrupalEasy faviconEvery Drupal 8 site should have a custom favicon that helps to reinforce the site's brand - of this there is really no argument. But, over the past (more than a few) years, the role of the lowly favicon has grown from just the little icon on a browser tab. These days, favicons are also used on mobile devices as the gateway to your site. Keeping your brand strong in all contexts is more important than ever.

Luckily, the Responsive Favicons module, combined with Favicon Generator makes it pretty easy to keep your site's branding consistent across multiple platforms. 

Favicon contexts

Assuming you have a relatively square-ish version of the site's logo, making this all happen is pretty easy.

First - head to Favicon Generator, upload the site's logo, then review/tweak the settings for the various contexts. You'll be asked for the "App name" (usually the site's name), suitable background colors (I selected a nice pear-color for the DrupalEasy logo - you can see it in the iOS mockup above), as well as image overrides (optional) for each context. For the "Favicon Generator options", select the "I will place favicon files at the root of my web site" option (at the recommendation of the Responsive Favicons module maintainers). At the end of the process, you'll get a zipped file full of all the necessary icons and meta data. 

Next, download and install the Responsive Favicons module. Head to its configuration area (/admin/config/user-interface/responsive_favicons) and complete the form. For the "Path to responsive favicon files", I just used "favicons". The "Favicons tags" section is provided at the end of the Favicon Generator's process. Finally, point the zip file generated by the Favicon Generator to the final form field. Click to "Save configuration" and you should be all set!

Lessons like this (and much, much more) are taught during our 12-week, 3x/week Drupal Career Online course. Learn more and register for our free Taste of Drupal webinar to dive into the details of the course.

Feb 19 2018
Feb 19
When I walk along with two others, from at least one I will be able to learn. 
 – Confucius

Drupal development as a career is usually also a commitment to constant learning through ongoing professional development.  Whether you make it a point to read blog posts or watch screencasts, sign up for some type of live-instructor training, or partake in co-working and meet-ups, on-going learning is a critical piece to being a professional Drupal  developer. Years ago, when DrupalEasy was presenting our Drupal Career Technical Education program exclusively in-person (now Drupal Career Online), the lab-portion (where we met in a less formal way than classroom sessions) became so popular with students, that we decided to continue to host them after graduation for anyone who had taken the class.

Six years later, these "office hours"are still going strong, now online and attended by people weekly from all over the country. It’s amazing to see the developers who first learned how to spell Drupal years ago in our riverside classroom in Cocoa, Florida; now the veterans assisting and connecting with those from recent sessions. People from former sessions, even those who attend at different times, also support each other beyond the labs, which has all contributed to the development of, what we think, is a pretty cool DrupalEasy Learning Community.

Weekly on Thursday afternoons U.S. Eastern Time, you can find DrupalEasy’s Mike Anello leading Go-To-Meeting ofice hours sessions, which are open to anyone who is enrolled in, or has taken any long-form DrupalEasy training courses. It’s a loose session devoted to helping anyone overcome issues, figure out how to approach something, share insights on particular modules and also talk Drupal. Learning experts call this collaborative learning, and it has even more advantages than we realized, which explains why it is so popular and seemingly effective as both an initial learning strategy and ongoing professional development tool. Everyone learns (Even Mike).

The Cornell University Center for Teaching Innovation explains that  “Collaborative learning is based on the view that knowledge is a social construct.”  (Wow, that relates to Drupal and open source projects on so many levels!)  They also explain that there are four principles to the ways collaborative learning happens, including that those who are learning are the primary focus, it is important to “do” and not just listen, working in groups is key, and the group should be learning by developing solutions to real problems.  

DrupalEasy’s learning community organically grew and developed all of these principles over the years, which is a pretty good confirmation that from both learning and solutions perspectives, we are on the right track. At the onset of each week’s office hours session, we say our hellos and figure out the first problem someone is having, or had, and the group works together to come up with a solution. There is of course also a bit of Nerd banter that keeps things fun and allows us to get to know each other a bit more. Cornell’s experts also confirm that group learning contributes to developing a lot of the soft skills (oral communication, leadership,etc.) that can help make a good developer great. We agree!

We also especially appreciate the value of the problem-solving approach to teaching, and also use it in our structured training. Cornell again has some great insight into the types and characteristics of problem solving as a mode of teaching that really resonates with us. They go in pretty broad and deep with references and explanations, so let’s pull the one element they cite that we feel we can attribute a good part of the success of our programs: “The problem is what drives the motivation and the learning.” (Boom!)  

So, knowledge is a social construct and problems motivate us to learn and figure out solutions. Working together as a community to overcome problems and build viable solutions. It’s all very Drupal-y, don’t you think?

The next session of Drupal Career Online begins March 26th. Two no-cost Taste-of-Drupal information sessions about the course are coming up at 1:30pm EST on February 28 and March 14.  Sign up!

Feb 03 2018
Feb 03

Over the past several weeks, I've been working with three of the more well-known Docker-based local development environments that involve a Drupal focus: Docksal, DDEV, and Lando. The goal is to not only to figure out which one I prefer, but also to figure out which our two long-form online Drupal training classes should potentially standardize on.

Docksal logoOur classes are often comprised of folks from all different technical backgrounds, so it is important that we not only teach them tools that Drupal professionals use, but also something that folks of myriad of skill levels can easily consume. Perhaps most importantly, while the majority of our students are on Mac OS X, we still have a consistent number of students using Windows, so any solution we recommend should work similarly on all platforms.

As a Mac OS X user myself, it is important to me that I can instruct our Windows-based students without having to resort to a separate set of instructions. To that end, I have an actual Windows 10 Pro machine (not a virtual machine) that I've been using to evaluate these local development environment options. 

I've decided to focus on DDEV, Lando, and Docksal because I really like the idea of Docker-based containers; being able to customize your local development environments to each project has too many advantages to ignore. Also, as one of our classes is Pantheon-focused, Lando's Pantheon integration is a very important differentiator. 

Requirements

DDEV logoI have a basic set of requirements that a local development environment should be able to handle. These requirements are probably focused more on our introductory Drupal Career Online course, but I'd like to be able to recommend the same solution for any of our courses.

  • Run Composer commands (including create-project). It doesn't matter to me if this command is run on the local OS or in a container, as long as it works with a minimum of fuss. The "create-project" command can be a bit tricky on Windows - keep reading to find out why.
  • Run Git commands both on the local OS and in the container. 
  • Be able to get up-and-running with a minimum of downloads. On Mac OS X this isn't much of an issue with Terminal, Git, and PHP preinstalled, but on Windows it is a different story.
  • Be able to get up-and-running with a minimum of "extra" configuration. Granted, once you're comfortable on the command line adding something to your local PATH isn't a big deal, but for folks new-ish to the command line, it can be a significant hurdle. 
  • Have a Linux-based command line interface (to use commands like cd, ls, cat, etc...)
  • Be able to easily (zero configuration) edit text files on the command line (nano or pico).
  • Be able to modify file permissions and ownership from the command line (chown and chmod).
  • Be able to run Drush, Drupal Console, and all of the other Drupal-y things that a professional developer should have.

I am very cognizant that my requirements are probably represent the lower-end of the Drupal skill-level spectrum, but I feel these requirements are a reasonable starting point.

Potential solution

Microsoft Windows 10 logoOver the past few weeks, I think I've installed, uninstalled, and reinstalled various combinations of Lando, Docksal, and DDEV as well as various command line shells (Babun, Cmder, PuTTY, Cygwin) and the Windows Subsystem for Linux at least a dozen times on my Windows machine. All this in an effort to figure out what is the best combination of tools to satisfy the requirements. At the current moment, I'm circling around recommending Lando and Cmder on Windows (Lando requires Windows 10 Pro with Hyper-V enabled) - both are easily installed with no extra configuration necessary to get almost everything working. 

Upsides

Lando logoWith just Lando and Cmder installed almost all of the requirements are met. I can use Git to clone a site down to my local, get it up and running in Lando and get to work.

Downsides

One minor issue is that Cmder doesn't come with nano nor pico for editing text files from the command line. It does come with vim, however (which we all know has a steeper learning curve). I can probably mitigate this issue with a little bit of config to have students run a command to open text files in something like Notepad++ or teach some basic vim commands.

The other issue is a bit more serious. With only Lando and Cmder installed, there's no way to run "composer create-project". While Lando makes Composer available in the container, developers don't normally create the containers until they have a code base. This is a bit of a chicken-and-egg issue:

  1. We need Composer to get the new code base.
  2. We need the Lando container to be up-and-running to get Composer.
  3. We need a code base before we start Lando.
  4. (return to step 1 above)

So, I think I know what you're thinking: just install Composer. Well, this isn't as simple as it sounds, as Composer requires PHP, and as far as I can tell, installing PHP on a Windows machine isn't super-straight-forward. Granted, if the developer already has another AMP stack on their Windows machine, the Composer install can be configured to use the php.exe installed with it. 

Docksal actually has a command that allows a developer to run Composer without actually having a set of containers already initialized for the project using the "fin run-cli" command. This utilizes a standalone cli container and completely removes the need to install Composer on the local OS. 

Next steps

So, where does that leave us? I'm not 100% sure, but I wanted to put this out there and get some feedback. Are you a professional Drupal developer that uses Windows as your main OS? If so, what's your setup? Am I missing anything? 

While I often try to steer new Drupal developers towards Mac OS X or Linux, sometimes it is not possible due to corporate policies or even just personal preference. I'd love to be able to teach a solution that provides a professional-level Drupal developer experience to Windows users.

Jan 31 2018
Jan 31

As trainers, feeders of the Drupal Talent pipeline, and researchers of strategies to attract and build the numbers and excellence of Drupal talent across the world, we spend a lot of time finding and training people in the ways of Drupal. Through resources, Mike Anello's many sessions and trainings at Camps and Cons, and through our flagship Drupal Career Technical Education program, we pursue our passion to teach more people Drupal. We think we have the training side of this down, but like the Drupal Community's general shortage of talent, it’s finding more people that is the challenge.

Why is that? And why aren’t there people coming in droves to this opportunity-rich, community-based vocation? We think it has a lot to do with a lack of the right information getting to the right people. Here at DrupalEasy, we fill a lot of (sometimes too much) time observing and noodling the various paths people take to find Drupal, aspects of Drupal as a career and reaching those who could benefit. We think if Drupal opportunities were presented more broadly, a bit better, and were more accessible to those who are not aware (especially those who historically have not embraced IT careers,) the floodgates (or at least a stream) might start to bolster up the Drupal talent pipeline.  

Drupal's foundations are really quite inspiring.  A vocation built on sharing - open source, an engaged community and building and developing the means upon which our societies connect, build relationships, find information, and buy & sell. The story is also quite practical; well-paying jobs a-plenty. According to Indeed.com, the average salary for "Drupal" ranges from approximately $59,980 per year for Web Designer to $110,572 per year for Full Stack Developer. 

In addition, the US Department of Labor Occupational Outlook, which provides official salary, job growth statistics and job descriptions for just about any career you might want to pursue, has some pretty convincing numbers as well. According to the DoL, Software Developer, Applications positions have a 30% growth rate, rank in the top 10 for job growth in the US, and have the third highest estimated salary! For web developers in particular, the DoL puts job growth at 15% over the next 8 years, which they cite as much faster than average. To put it in perspective, electrical engineerin job growth is predicted to be 7% – less than half of that of web developers.  

So with all of this opportunity, where are all the aspiring Drupal developers? Apparently somewhere they are privy to neither the Drupal narrative nor Web developer job stats.  We have several ideas, some big, others not too difficult, on how to overcome our shortage of talent, as we outline in List #5 to provoke some thought and perhaps follow up from those who feel the pain of the Drupal talent shortage.  We'd love to hear from you. 

But perhaps we can all give small efforts a go to see where it might improve things on a smaller scale; beginning with awareness we can build within and on the fringes of our personal and professional networks. So, in the spirit of spreading the word about how great the opportunities are in Drupal, we thought we would compile a few easily shareable lists you may want to dole out to those around you. We'd also love for you to share with us your lists (and ideas) that may make Drupal a bit more accessible to those who may become a part of this engaging community. 

#1  Top 10 Drupal Talent-Starved States

If you live in one of the 10 states listed below, especially near the major metropolitan areas, your outlook for finding a Drupal job is pretty positive. Likewise if you are looking for talent in these places, we feel your pain. The list includes the highest number of open positions we found on Indeed. (To be fair, if you live in Idaho, Mississippi, Nebraska, South Dakota or Wyoming, the chances of finding a commuter/non-distributed position in Drupal is pretty slim, considering we could not find a single open position in any of these states using a pretty comprehensive list of job search sites.)  

  1. California: 270

  2. New York: 233

  3. Virginia: 130

  4. Maryland: 118

  5. Massachusetts: 106

  6. Pennsylvania: 95

  7. Texas: 85

  8. Washington: 60

  9. (tie)Florida: 55

  10. (tie) Illinois: 55

[*Source, Indeed.com, as of January 29, 2018. (Indeed has the greatest number, therefore the most complete list, of Drupal job openings. It also provides the tools to ensure accuracy. The other sites support these rankings, ]

# 2 Top 10 Jobs Sites to find Drupal Positions (by number of Drupal jobs and ease of calculation!)

We went on a job finding expedition earlier this week to see where people looking for Drupal jobs or just gauging the opportunities have the best shot. Indeed.com won by shear numbers, but also because they make searching, and compiling information like these lists the easiest. The list includes the site and the number of Drupal and Drupal related jobs in the United States as of January 29, 2018. 

1 Indeed; 2,015

2 Glass Door; 2,012

3 Simplyhired;1,798

4 Monster; 1,164

5 job.net ~500

6 ihiretechnology; 491

7 Justtechjobs; 273

8 Dice; 259

CareerBuilder; 135

10 DrupalJobs; 80

*Of note:  I tried not to use sites that compile listings from other sites, like Ziprecruiter, but many sites now share listings. Also, if you are looking specifically for a federal government job, try USAjobs.gov

#3 Top 10 Drupaliest Companies in the US

For those who wish to get into larger organizations (by Drupal size standards of course) with lots of Drupal people to associate with throughout the day, the companies who have the greatest number of employees registered on Drupal.org, and have headquarters or major facilities in the US are listed in order of Drupaliness, which means according to the number staff members on Drupal.org.

  1. Acquia; 618

  2. FFW; 231

  3. CI&T; 220

  4. Cognizant; 117

  5. Phase2; 92

  6. Pantheon; 86

  7. Booz Allen Hamilton; 74

  8. Appnovation; 69

  9. Epam; 68

  10. Mediacurrent; 67

[Source Drupal.org: Organizations using Drupal: United States which shows the number of employees who are on Drupal.org.]

# 4. Top Ten Articles to Guide Aspiring Drupal Developers

OK, so we’ll preface this by again explaining that we spend a lot of time thinking about, researching, interviewing, writing and presenting a lot of materials on Drupal careers and jobs. That said, you’ll see quite a few entries below with our fingerprints on them. Not sure how to shed the cloak of shameless promotion, but avoiding it does not seem like a good reason to leave out helpful information (we’ll take whatever sneers you'd like to offer.) The list was compiled from a variety of Google searches using several key words and variations, and based on our impressions of the credibility and helpfulness of the information.  If you have any additional materials that we missed and you’d like to share, please let us know and we’ll add it to our Career Resources Page.

  1. How Do I Start a Career in Drupal? DrupalEasy Academy Resources page

  2. Why Become a Drupal Developer? Drupal Partners, August 2015

  3. How Do I get a Job in Drupal?; OSTraining’s March, 2015

  4. Become a Drupal Developer, Drupalize.me

  5. What Does it Mean to Be a Drupal Developer?; Promet Source, August 2016

  6. How to Become a Successfull Web Developer; Mobomo, August  2016

  7. How to Become a Successful Web Developer, Zyware; 2015

  8. 6 Steps for New Drupal 8 Developers; Web Omlette

  9. What Skills should a Drupal Developer Have? ValueBound, February 2017

  10. Drupal Career Resources; DrupalEasy Academy

# 5. Top 10 ways to grow Drupal Talent

This one is for all of us, especially the folks on the #3 list, who, we noticed are among many of the companies tallying up the numbers for states on list #2. Since we started Drupal Career Training, we have met with dozens of people, educational institutions, workforce boards, other Drupal training companies and all sorts and sizes of companies about the Drupal talent shortage issues, the lack of diversity issue, and the "lack of experience" issue for those new to Drupal. We feel like if just a few in the community, together or independently, start any of these initiatives, it will go a long way in ensuring that the 15% growth in web developer positions is not lost on Drupal in the future. The only resource for this list is the collection of ideas we have heard, discussed, conceptualized, written into white papers and schemed up during DrupalEasy lunches. If you have another idea, or want our help getting one of these concepts going, let us know.

  1. Collaborate with other companies, especially in the states that made the #2 list, to reach out to regional workforce agencies to get them involved in finding and underwriting training for potential Drupal hires.

  2. Develop geographic mentoring networks for those considering and new to Drupal through the local users’ groups.

  3. Take on Interns (Contact DrupalEasy for well-trained candidates or find them at local meetups.)

  4. Develop a Drupal community scholarship fund for under-represented groups to use one of the many Drupal Training organizations to get skilled up in Drupal.

  5. Partner with Not-For-Profits to fund Drupal training, mentoring and internship programs for women, minorities, veterans, and other underutilized populations.

  6. Promote Drupal as a career in your local and non-Drupal community outreach. 

  7. Reach out to contacts at local colleges about adding Drupal to their curriculum (DrupalEasy’s state licensed Career Technical Education program is an option.)

  8. Host/sponsor beginner information nights at Meetups.

  9. Share these lists to spark interest and action.

  10. Contact DrupalEasy to help with these or any other ideas you may have!

 

The Spring 2018 session of DrupalEasy's Drupal Career Online training begins on March 26th, with two more free informational webinars about the course in February and March. Registration is also open for the Spring Session of Mastering Professional Drupal Developer Workflows with Pantheon, which starts on February 28th. 

 

Jan 27 2018
Jan 27

Over the past few months, I've been test-driving various Docker-based local development environments with two goals in mind. First, as my "daily driver" for consulting work - I've been a long-time MAMP Pro user and I've been feeling for a long time that I need to modernize my local development tools. Second, I'm trying to figure out what is the most ideal local development environment for students of both our 12-week Drupal Career Online class (starts March 19) and our 6-week Mastering Professional Drupal Development Workflows with Pantheon (starts February 26) courses. 

One of the necessary skills for a professional Drupal developer (one who codes either modules or themes) is to be able run a solid debugging tool. As part of my evaluation of Lando, I decided to figure out how to set up local PHP debugging with Xdebug and PhpStorm on Mac OS X.

This process described below is largely based on a comment in an issue thread in the Lando issue queue by David Hunt - thanks, David!

My local setup includes:

  • Mac OS X Sierra 10.12.6  
  • Lando v3.0.0-beta.21  
  • Google Chrome with the Xdebug helper extension 
  • PhpStorm 2016.1.1  

Starting point

This tutorial assumes that you have a local Drupal site up-and-running in Lando and set up as a project in PhpStorm. In this example, my local site is using the Lando "Pantheon" recipe, but as you'll see in a bit, any recipe can be used. Also - my local site is based on the standard Drupal project composer template (with a nested docroot).

PhpStorm project

Enable Xdebug in Lando

The first step is to enable Xdebug in Lando - this is easily done by modifying the local site's .lando.yml file. In my case, I added the following:
 

Enabling Xdebug in Lando

If your .lando.yml file is defining a custom appserver service, then you should be able to just add the "xdebug: true" bit to the appserver definition. 

Once added, you'll need to perform a "lando rebuild" - this will rebuild your environment based on your .lando.yml, including adding Xdebug. The documentation page for the "rebuild" command includes a caution about how there's no guarantee that data will persist between rebuilds. In my experience, I haven't had any issues with losing my database. If you're concerned, then you may want to perform a "lando db-export" prior to rebuilding.  

Configuring PhpStorm

Here's where some magic comes in. Admittedly, I don't fully understand the details of some of the configuration necessary in PhpStorm to get debugging working, but I can confirm that following these steps, it has worked every time for me so far.

The first step is to add the Lando recipe folder as an "Include path" in your PhpStorm project. Open Preferences > Languages & Frameworks > PHP, click the "+" button at the bottom of the list, and manually type in the name of the folder of the Lando recipe you're using. On my machine it is: /Users/michael/.lando/services/config/pantheon. If you're using the standard "Drupal8" recipe, then it would be: /Users/michael/.lando/services/config/drupal8. Unless your username is also "michael", you'll want to update the path.
 

PhpStorm PHP preferences

Then, go to Preferences > Languages & Frameworks > PHP > Servers

PhpStorm listening for incoming connectionsIf no server for your project exists (it might be called “appserver”), then enable PhpStorm to listen for Xdebug connections, load a page from your local site in your browser and PhpStorm will prompt you to accept the incoming connection. In my case, it didn’t matter if the Xdebug helper is set to debugging or disabled at this point.
 

Incoming connection from Xdebug

Then, once a server for your local site exists (remember, it might be called "appserver”), select it and ensure that "Use path mappings" is checked, and ensure that your project folder is mapped to "/app" for the "Absolute path on server". Also ensure that the "Absolute path for the server" for the “include path” is "/srv/includes".

PhpStorm PHP Servers preferences

Give it a try!

At this point, we should be ready for debugging! As a test, open up the site's index.php in PhpStorm and place a breakpoint.

PhpStorm set a breakpoint.

Then, using the Xdebug Helper extension, enable debugging. Also ensure that PhpStorm is still set to listen to incoming Xdebug connections. 

Xdebug helper enable debugging

Finally, load your local site's home and watch how PhpStorm will pause code execution at your breakpoint in the index.php file.
 

PhpStorm debugger working.

Warning - performance will suffer

While Xdebug is a powerful tool and will absolutely save you loads of time, there's a dark side. Performance will suffer. I recommend disabling Xdebug in your .lando.yml - by setting "xdebug: false" - (and rebuilding) when you're not using it. You can leave it enabled and gain back some (but not all) performance by disabling PhpStorm's listener as well. 

Final thoughts

In case you're wondering where some of the configuration settings come from, here's what I've figured out so far:

  • "appserver" is the name of the Lando service that contains the codebase. 
  • "/app" is the absolute path of the codebase in the "appserver" Docker container. 
  • "/srv/includes" is the absolute path to a Lando-provided "prepend.php" file in the "appserver" Docker container. As far as I can tell, this file defines and sets a bunch of environment variables depending on the recipe used.
     
Jan 21 2018
Jan 21

Over the past few months, I've been evaluating three Docker-based local development environments trying to figure out which is best not only for me, but also for students of our long-form Managing Professional Drupal Development Workflows with Pantheon (next semester starts February 17) and Drupal Career Online (March 26) classes.

I've been test driving Docksal (actually, I've been using it for over a year), DDEV Community, and Lando (I'm a recovering Kalabox user) trying to figure out where the "sweet spot" is for flexibility, ease of use, documentation, Windows-compatibility (we routinely have students on Windows machines), performance, and some other criteria.

I recently stumbled upon a cool open source project (thanks Brian!) called Mailhog that makes it dead easy to test outgoing emails from a local development environment. While I tested it on Lando, both Docksal and DDEV both support Mailhog and have supporting documentation here and here

The general idea of Mailhog is that it acts as a local STMP server that by default, doesn't send emails to the addressed recipients. Rather, it includes a clean UI that allows the developer to view outgoing emails. 

Getting Mailhog up-and-running in an existing Lando site is quite easy. Simply add the following to your .lando.yml

proxy:
  mailhog:
    - mail.lemp.lndo.site
services:
  mailhog:
    type: mailhog
    hogfrom:
      - appserver


You'll probably want to change the URL of the Mailhog UI from "mail.lemp.lndo.site" to something specific to your project - in my case, I should have set it to "mail.de8.lndo.site".

Then, run "lando rebuild". Caution should be used when using this command, as while most services retain their data during a rebuild, some may not. So far, I can confirm that my databases come through just fine. 

After rebuilding, you're just about done. When you run "lando start" the next time, you'll see a new set of URLs for the local Mailhog UI (you can also get this information via "lando info").

Mailhog local URLs

On your local Drupal site, if you're using the SMTP module or another SMTP-based sending solution, be sure to disable it:

Turn SMTP off.

Then, sending an email from a local contact form (screenshot shows a local copy of DrupalEasy.com):

Contact us form

Results in this in the Mailhog UI:

Mailhog interface

Then, if you want to "release" a message to its intended recipient, Mailhog provides you the option to do that as well via a button when viewing an email:

Mailhog release button

The button leads to an SMTP settings form:

Mailhog STMP release settings

Summarizing, regardless of if you're using Lando, Docksal, DDEV, or another local development stack, Mailhog is a great tool to help you test sending emails from your local development environments. 

While the screenshots in the blog post demonstrate setting up Mailhog with Lando, I can confirm that the process is just as easy with Docksal using the documentation, as I was able to configure it for a local client site in about 5 minutes.

For more information about using Mailhog with Lando, see the official documentation page.  
 

Jan 16 2018
Jan 16

Spoiler alert! If you haven't seen “The Last Jedi” yet, this blog post includes what can be considered a minor spoiler. I've seen the movie a few times now (I saw the original Star Wars movie when I was 7 years old, and I've been hooked ever since), and I've been able to fully indoctrinate at least one of my kids in my love for the series. When we first saw the movie on opening night, there was a line of dialog that resonated with me more than usual - I've been thinking about that line for over a month now and have figured out how to relate my love of Star Wars with my obsession for teaching Drupal. 

"The Greatest Teacher, Failure Is"

There's a point in the movie when Yoda is speaking to another character and utters this line. As a former mechanical/aerospace engineering college adjunct professor and a current Drupal trainer, I've always believed that for a lesson to truly take hold, there has to be a little bit of pain - not physical pain, but rather the kind of pain that comes from doing something incorrectly (often numerous times) before realizing the proper way of doing something that leads to a more satisfying, correct (and often efficient) result. As usual, I didn't have the proper words to describe it - thanks to Yoda, I do now.

As I look back at my eleven years in the Drupal community, I can point to more things that I care to admit that I didn't do correctly the first time. If I narrow that list to technical mistakes, it becomes very clear that many of the mistakes I've made have had a direct impact on the curriculum I've written for our various training classes.

As we gear up to teach Mastering Professional Development Workflows with Pantheon for the second time, allow me to share some of the failures I've had in the past and how they've had a direct result on the curriculum for this 6-week class.

  1. "Everything is a content type" - this is something I learned only by repeatedly designing the information architecture for various sites that ended up not being able to completely fulfill all the project's requirements. Understanding the differences between various kinds of entities is key to building a sustainable site that meets 100% of a project's requirements.
  2. "Core search is fine" - I'm embarrassed to say how late I was to get on board the Search API train. Being able to provide faceted search to clients of all sizes is a huge win.
  3. "I don't need the command line" - looking back at the first half-ish of my Drupal career, I used Drush only when absolutely necessary. Not learning basic command line tools until well into Drupal 7 definitely held me back. With Drupal 8, if you want to be a professional Drupal developer, there is no way to avoid it. Luckily, using command line tools like Composer, Drush, and Drupal Console are not only "the right thing to do", but also save time. 
  4. "MAMP is fine" - I was late to the party in moving my local development environment from MAMP and Acquia Dev Desktop to a Docker-based solution. I had played around a bit with virtualized solutions, but once you get accustomed to a professional-grade, modern, Docker-based solution, you'll never go back.

While I could list additional examples (multi-branch development, configuration management, display modes) of previous failures - or even one or two that I feel like I'm currently failing (test-driven development), the point is that sometimes it is necessary to fail in order to really understand the value of a success. 

DrupalEasy's 6-week live, online Mastering Professional Development Workflows with Pantheon, not coincidentally, addresses the failures listed above. The next session begins on February 27, 2018.  

The next session (our 11th!) of our 12-week, live, online more-introductory-focused Drupal Career Online begins March 26, 2018.
 

Jan 09 2018
Jan 09

The following is a guest blog post by Brian Coffelt.

Brian Coffelt

Train to Reign

I’m surprised often by the slow adoption rate of quality development workflows. Time probably plays a big part. One thing I have experienced though, is that in order to get the full value of tools, especially software, you really need to spend the time learning how to use them properly.  

Since I changed my career to become a Drupal developer, I haven’t had a day of regret, nor a day when I did not realize that the key to success is learning more: More about the software, more about techniques, and more about the tools that make Drupal development better. It all feeds into what I learned early on in DrupalEasy’s Career training program, and that I still feel are the best parts of this amazing Drupal-based vocation: to create quality work and become part of the Community.

So when I had the chance to take DrupalEasy’s Mastering Pantheon Workflows course, I jumped at it.  I have been relying on (and loving!) Pantheon’s website management platform since my early career training, and am a huge fan of the great workflow and development tools it offers.  The Workflows class, which is several afternoons a week for six weeks, was time truly well spent. It taught me to really leverage Pantheon’s advantages, and has made me a better developer.

Top 5 Takeaways

The quality of the curriculum and instruction of this course are second to none.  I mean it. DrupalEasy’s insight on what is important provides tremendous value to the time spent in the class and honing your skills. As any professional web developer knows, a great development workflow is worth its weight in gold. This class helped me learn a Docker-based local development workflow that has been directly applied to my everyday routine as well as that of my team.  In addition, learning how Composer manages dependencies was an eye opener for me. It allows my projects to be very lean, efficient, and modular. There are plenty more topics I can point to, but the top 5 area’s we covered that make my day-to-day better and easier are:

  1. Composer integration and dependency management
  2. Drupal 8 configuration management (exporting & importing)
  3. Docksal/Lando local environment structure & setup
  4. Higher level Terminus commands
  5. Development workflows between Pantheon environments and local

The instruction, either direct or via additional screencasts, was always thorough, well planned, and thoughtful. The instructor, Mike Anello (@ultimike), always allows time for questions and troubleshooting. Integrating a class Slack channel was valuable for questions and troubleshooting between classes as well as resource sharing (links, documents, etc.). I still keep in contact with my classmates as often as I can via Slack, email or Drupal events.

Worth the time

It may seem like a few afternoons a week for six weeks will chew up your schedule, but in fact, the opposite is the case. The skills acquired from this class can immediately boost your production, proficiency, and overall value, all of which are well worth the financial and time commitment.

I am definitely a better Drupal developer after having taken the Workflows course. The knowledge, experience, and overall comfort level I achieved has given me valuable skills that I use and share with others every day. The class always stresses the pursuit of best practices to minimize development time and maximize results. I recommend this course to Drupal developers looking to streamline their Pantheon development workflow. It’s certainly well worth the investment.

DrupalEasy’s next Mastering Professional Drupal Development Workflows with Pantheon course starts in February.  Contact DrupalEasy for more information.

Dec 26 2017
Dec 26

We'd like to introduce the Fall, 2107 graduates of Drupal Career Online (DCO), DrupalEasy's exclusive 12-week, live online Drupal training program. This is our 11th graduating class and the first of our recently updated all Drupal 8 curriculum.

Fall 2017 Drupal Career Online class photo

Class members include (from top, left):

  • Michael Anello (instructor)
  • Adrian Nolt
  • Lisa Streeter
  • Jared Nolt
  • John MacDonald
  • Steve Versteeg
  • Alona Kotliar
  • Evrim Campbell
  • Donald Sangster
  • Madeeha Kahn (below)

Madeeha KahnWhile many of this semester's graduates have pre-existing full-time jobs, several are aspiring Drupal contractors and consultants, so if you're looking for a junior level Drupal developer or intern, don't hesitate to let us know

This semester's class included Drupal 7 site builders looking to learn Drupal 8 workflows and module development, a WordPress developer and a self-taught Drupal 8 developer looking to learn best practices, as well as several Drupal hobbyists looking to learn professional development techniques.

Our always-being-updated curriculum dropped support for Drupal 7 with this most recent class. The curriculum now teaches Drupal 8 best practices around using Composer to manage site codebases, Drupal Console for module development, and proper use of Drupal's settings.php and settings.local.php files. 

The next semester of Drupal Career Online begins March 26 - learn more about it.  

We're also offering our Mastering Professional Drupal Developer Workflows with Pantheon class starting February 27. This 6-week, 3 half-day per week, live online class is for those with previous Drupal development experience who are looking to learn professional Drupal 8 workflows focusing on Composer and Pantheon. In addition, there are dedicated lessons about Drupal information architecture, using Search API and Solr, and utilizing advanced Pantheon hosting features. 
 

Aug 22 2017
Aug 22

Resources to learn Drupal are many and certainly vary in delivery, focus and quality. When you are trying to figure out the best way to train up, considerations like schedules, learning styles, and trainer reputations play pretty heavily. You also need to look at the program and compare it to what you already know, what you need to know, and what you should know to get into practice as quickly possible. One of the biggest obstacles is often finding, and then choosing the training program(s) that are right for you, and perhaps your team. But what if you didn’t have to choose?

Drupalize.me and DrupalEasy are proud to announce that we are making it easier to get trained up in Drupal in a way that helps overcome challenges, meets needs, and addresses the different ways people learn. We are bundling our training programs and resources beginning with DrupalEasy’s Fall 2017 session of Drupal Career Online. The DCO will include access to all of the thousands of Drupalize.me tutorials during the 12-week course, and a deeply discounted subscription after graduation. Current Drupalize.me subscribers will also receive a special Drupalize.me tuition rate for this and any future sessions of the DCO.

Drupalize.me’s Addison Berry came up with the partnership idea as a way to help the community grow by helping along the learning process of people who can more quickly become solid developers. Addi says, “Any way we can make it easier, and better for people to get quality training to become developers is good for the community, and good for all of us.” In addition to providing comprehensive Drupal training that focuses on best practices, Drupalize.me and DrupalEasy share a love of building the Drupal talent base across the world.

Drupalize.me provides a premium, membership-based training library of thousands of tutorials divided into specific pathways according to your learning goals. It is trusted by users around the world, and backed by Lullabot, one of the top open source strategy, design, and development companies.

DrupalEasy has been offering instructor-led comprehensive Drupal career technical education (the first of its kind) programs since 2011, launching the 12-week, 132 hour Drupal Career Online program in 2015. The DCO ensures individuals and teams can rely on expert live instruction, office hours and mentorship, expansive learning resources, and a curriculum that thoughtfully stacks skills and emphasizes best practices to ensure graduates have the best possible foundation to become practicing Drupal developers.

The first session of Drupal Career Online that includes unfettered access to the Drupalize.me’s tutorials in the Site Building, Theming and Development learning pathways begins October 2, with an application deadline of September 26th. To learn more and get an idea of the DrupalEasy learning platform, sign up for one of two Taste of Drupal free information sessions in August and September or contact DrupalEasy.

Jul 30 2017
Jul 30

Brian Coffelt

We've had more than 100 students complete our 12-week Drupal Career long-form training since 2011, working with individuals, teams, young and old, men and women, all with different backgrounds, abilities, motivations and aspirations. We've seen talents explode, helped keep people engaged and even watched interest fizzle. About the only constant is that everyone in every class wants to or needs to learn Drupal, whether they have decided on their own, or need to build their Drupal talent as part of a developer team.

Every so often, we run into a student who really brings to life our vision of what the course can help people accomplish; someone who does everything before, during and after that just exudes enthusiasm and commitment toward predictable success. Brian Coffelt (@briancoffelt), a student in the Spring 2015 Drupal Career Online session, and now Web Administrator and Developer for Duke Cancer Institute in Durham, NC, is one of those sensations.

Brian, after 15 years of serving as a public school health and physical education teacher, realized he was in a situation that fell short of providing him the professional fulfillment and the type of income potential he desired. "I wanted to challenge myself and better provide for my family," he recalls. "I learned of Drupal from my brother-in-law (Shaun Heath, an earlier DrupalEasy graduate) and began to research how powerful Drupal was. I also saw a great need for quality Drupal developers and a promising job market."

The Drupal job market was actually the key ingredient in the creation of DrupalEasy's long-form career technical education program, which was born as a solution for Florida's Space Coast when the end of the Shuttle program left about 7,000 people, including lots of IT-types, without jobs. The in-person course was a hit, and the positive outcomes led us to make things official, with a license through the Florida Department of Education, Commission for Independent Education, which we continually qualify for and renew annually. Since we moved the course live-online, we've been able to train up people in Drupal from all over the country.

Brian lived in Nashville at the time he started the program. He came to us with a not-so relevant degree in education, but made up for it with true desire, commitment and hard work. He dove straight into course curriculum as a star student from the first day. "His comprehension was very high, most likely because of his diligence and strong interest in the topics," says Mike Anello (@ultimike), who created and teaches the DCO. It also had a lot to do with his self-study before the class even started; delving into a roadmap of languages, frameworks, and workflows that Shaun provided and that he researched in preparation.

"During the training, I made it a point to watch all DCO webcasts before class to ensure that I retained the concepts. Mike also recommended additional courses and topics to look into which I took full advantage of," he explained. He also participated in every optional co-working lab during the course, and completed every assignment and project. Brian was very comfortable with his abilities, and once the course ended, skipped going for an internship and sent out applications and landed a full-time Drupal developer job almost immediately. Brian and his family later relocated from Tennessee to North Carolina for his current position, where he's found his niche in front-end development for Duke.

Even now, Brian is still eager to learn. "I try to attend the DrupalEasy office hours when it fits into my work schedule," he says. Mike holds Thursday office hours for all current and former students, to get information and help with issues, both from Mike and the others in the DrupalEasy learning community that's been formed. The learning community, especially former classmates are important to Brian as well. He keeps in touch with one fellow student several times a week, with whom he has also collaborated on Drupal projects and attend DrupalCamps together.

Brian maintains his status as a rising star in Drupal by seeking out professional development and Drupal learning as much as possible, attending local Drupal meetups as often as he can, participating in the Duke Drupal users group and going to camps and cons when he can. He also spends at least a couple of hours a week reading up on the newest trends in Drupal, although, he explains, "Fatherhood cuts into my reading time quite a bit."

According to Brian, "the best part of Drupal development is the satisfaction that comes with creating quality work. A close second would be the Drupal community." He set out with a goal for professional fulfillment and greater opportunities for his family. "My new Drupal career has allowed me to attend events throughout the country. The pay scale and benefits available to me now greatly outweigh those of a public school teacher. I also enjoy the ability to work remotely from home when needed. This flexibility is in stark contrast to my previous profession," he explains. Mission accomplished!

He also offers a bit of guidance for those looking to become Drupal developers. "My advice to someone learning Drupal is that you get what you put into it. If you sacrifice your time and energy, Drupal can be very rewarding. There's plenty of opportunities for those who are willing to work hard and push themselves." he explains. He continued, "I can't recommend DrupalEasy enough! It has opened so many doors for me and the instruction I received was second to none!"

The next session of Drupal Career Online starts in October. You can learn more about Drupal, Drupal Careers and our career training program at an upcoming Taste of Drupal free mini-webinar.

Jun 12 2017
Jun 12

Over the past 6 years, we've training hundreds of people through our 12-week Drupal Career Online class, our new 6-week Mastering Professional Drupal Developer Workflows with Pantheon class, as well as our dozens of public and private trainings (literally) around the world. As part of our long-form 12- and 6-week classes, we've been providing on-going support for our graduates in the form of DrupalEasy Office Hours.

Each week, we set aside two hours for any current student or graduate of any of our long-form classes to join our online classroom to ask just about any Drupal-related question they have. It might be about a project they're working on, something they learned in the course, or advice on how to tackle something that is a bit outside of their comfort zone. Regularly using screen-sharing, we can almost always help the person with their request - and most of the time, those watching pick up a thing or two as well.

The most rewarding aspect of DrupalEasy Office Hours (for us, at least) is watching students helping students. As Robert A. Heinlein once said, "when one teaches, two learn" is something that we try to encourage in all of our classes as well as DrupalEasy Office Hours.

This type of learning community has been a hallmark of what DrupalEasy training, consulting, and project coaching is all about. By engaging a subset of the larger Drupal community, our students gain experience, knowledge, and most of all - the confidence to ask fellow community members for help in an environment that is supportive and nurturing. 

Over the past few years, we've heard of similar programs by various Drupal shops who provide a similar service for their clients. We can't think of a better way to provide on-going goodwill and mentoring.

If you're a graduate of one of our long-form classes, be sure to pop-in and say hello (contact us for details). 

Mar 10 2017
Mar 10

Drupal Console logo is a fantastic tool for helping to write Drupal 8 modules; of that there is little debate. Its "generate" functionality takes much of the pain out of setting up the scaffolding for many types of Drupal 8 modules, and in the process that alone saves developers a significant amount of time. When using Drupal Console, module developers usually don't have to worry too much about basic "use" statements, PSR-4 directory structures and file names, annotations, and much boilerplate code that is normally part of the development process.

Here at DrupalEasy, we're such big fans of Drupal Console, we've designed our "Introduction to Drupal 8 Module Development" full-day workshop around it (<shameless-plug>we're offering it at DrupalCon Baltimore</shameless-plug>). To some newcomers, getting Drupal Console up-and-running can be a bit tedious as there are a few ways to install it. Plus, the distinction between the Drupal Console Launcher (global executable) and the rest of Drupal Console can be confusing.

This blog post's goal is to describe one method for installing Drupal Console Launcher and Drupal Console on an existing Drupal 8 site. This example will not utilize a fully-Composer-ized™ Drupal 8 install (possibly expect a second blog post once best practices evolve a bit more - see below), rather it will focus on a "standard" (old school?) Drupal install via traditional methods. That being said, you'll still need Composer installed, as we're going to use it to install part of Drupal Console (a bit confusing, I know). 

So, let's assume you have a local Drupal 8 instance installed and up-and-running on your local machine. For this exercise, your local development environment doesn't matter all that much unless you're running a virtualized solution. If you are, you're probably clever enough to modify these instructions appropriately. In the past, I've often used Acquia Dev Desktop when teaching new students to use Drupal, so I can confirm that these instructions work just fine in that environment. The only real prerequisite is that Drupal Console requires PHP 5.5.9 (on the command line) or higher.

As mentioned above, there are actually two parts of Drupal Console that users are strongly recommended to install - the "Drupal Console Launcher" and "Drupal Console" itself. The launcher is installed globally on your machine, while Drupal Console is installed separately on each of your local Drupal 8 projects. This is a bit different than earlier (pre-release-candidate) versions of Drupal Console, and can be a source of confusion.

Installing the launcher should be pretty straight-forward on Mac or Linux as there's a simple curl command:

curl https://drupalconsole.com/installer -L -o drupal.phar

Once downloaded, run:

mv drupal.phar /usr/local/bin/drupal
chmod +x /usr/local/bin/drupal

These commands will move the launcher into your /usr/local/bin directory and set it to be executable by everyone. You may need to use "sudo" with the "mv" command.

On Windows the project documentation is pretty good (as well as this Evolving Web blog post by Dave Vasilevsky). With just the launcher installed, you're limited to just a few Drupal Console commands involving installing (via the very cool "chain" command) Drupal, working with generic .yml files, and some Drupal Console non-site-specific functionality. 

You can verify the launcher is installed properly by doing a drupal about command from anywhere in your file system - this will show you the current version of the launcher as well as some available commands. 

It is the launcher's job to provide the global executable for which to run Drupal Console commands against any site on your system from any location (using the --root option - similar to the Drush --uri option) or by running the command from inside the site root. 

But, in order to run most Drupal Console commands (including the glorious "generate" related ones), each Drupal 8 site on your local must have Drupal Console (and its dependencies) installed. Luckily, this is pretty easy to do as well. Navigate into your site root, then (because Drupal 8 ships with composer support) run the following command to install:

composer require drupal/console:~1.0 --prefer-dist --optimize-autoloader --sort-packages

This will modify your site's composer.json and composer.lock files with their new Drupal Console dependency and then download Drupal Console and all of its dependencies into the site's vendor directory. That's it - you're done! Remember - you must do this for each Drupal 8 site on your local. 

You can test the Drupal Console goodness with a drupal site:status command (similar to drush status). Once confirmed, you're good to start using Drupal Console to help you generate all those custom modules.

Updating Drupal Console

Looking at the Drupal Console project page, it's easy to see that it's still a work in progress (there are commits almost daily). So, the next (hopefully) obvious question is "how do I update Drupal Console"? Well, first off, remember that there are now two things to update - the global launcher as well as all the Drupal Console stuff in your site's vendor directory. 

To update the global launcher, navigate to somewhere outside of your Drupal 8 site (your home directory works) and run drupal self-update (you may need to use "sudo"). 

To update your site's Drupal Console "stuff" (I'm struggling to figure out exactly what to call it - "files"? "dependencies"?, "code"? I'm open to suggestions), navigate to your site root and, remembering that we used Composer to install it, run the following command to update it:

composer update drupal/console --with-dependencies

Keep in mind that you'll need to do this for each Drupal 8 site on your machine.

The Future?

So, what will the differences in this blog post be once we all fully embrace Composer as the-one-and-only-way-to-manage-Drupal-projects? I'm not entirely sure there will be any. Stay tuned.

Feb 27 2017
Feb 27

People in auditorium

Last weekend the Florida Drupal community hosted its ninth annual Florida DrupalCamp (FLDC) at Florida Technical College in Orlando.  It was a great success. At this point, we (the organizers) have a pretty good idea how to put on this event. (Since a good number of us have been involved in all nine iterations, (and all still seem to like each other!) some aspects of the camp organizing process are on veritable auto-pilot.

If you're a camp organizer, you know what goes into securing sponsors and a location, spreading the word, finding presenters, arranging for swag and catering, etc… For this year's event, we wanted to step things up a bit by focusing on three things: more learning, more fun, and more networking. Based on feedback and our own experiences, we feel like we achieved all three goals with some changes from previous years' camp recipes.

More Learning

In the past, FLDC has been a 2-day event; Saturday has been the main event - a day full of sessions, while Sunday has been a "community day" with sprints, Coding for a Cause, BoFs, and a generally less-defined schedule. 

This year we decided we stepped it up to a full-on three-day event; full-day training workshops on Friday, sessions on Saturday and Sunday, as well as a professionally mentored code sprint on Sunday. 

Adam Bergstein session

With the generosity of five trainers, we were able to provide full-day workshops to almost 80 people on Friday. Many, many, many thanks to our trainers:

Code sprint

The other change to facilitate more learning is to provide experienced sprint mentors for our Sunday sprint. With a nudge or two (maybe three) from xjm, we decided to have a Major Issue Triage Sprint at this year's camp. We brought in YesCT and nerdstein to mentor the sprinters to great success. During the Sunday sprint, we were able to make progress on well over 20 Drupal core major issues.

Finally, we decided to bring in Kevin Thull (@kevinjthull) to handle all the session recording, processing, and uploading for the event. Kevin's work with recording other Drupal events is top-notch. Having all of our sessions recorded will allow those who weren't able to attend (or those who did attend but couldn't make a particular session) to be able to benefit from our speakers. All of the sessions are currently posted on our website schedule, as well as on our Youtube channel.

More Networking

Traditionally, we have always had a full-day beginner track on the main day of the camp. This had the effect of keeping the vast majority of the beginners in the same room all day - limiting their networking opportunities. By having a full-day introductory workshop on Friday, beginners became fully-involved in camp activities the rest of the weekend. The feedback we received from this change is overwhelmingly positive.

The other big-ish change aimed at more networking was to increase the amount of time between each session to a full 30 minutes. This had the side-effect of us having fewer sessions on Saturday, but was mitigated by adding a half-day of sessions on Sunday. Again, the response we received from this change was overwhelmingly positive. It provided a less "rushed" day for all attendees, gave presenters a little more leeway if they went a few minutes over their allotted window, and provided ample time for the hallway track. In addition, our sponsors loved this change, as it gave attendees more time to stop and chat with sponsors in our exhibition area. 

During the closing session, we announced that any leftover funds from the event can (and should!) be used by Florida local meetup organizers to promote and grow their local meetups. In the past, we've informally made these funds available, but we're going all-in this year. If you're a Florida Drupal meetup organizer, we have $$$ for you for meetup.com memberships, food for your meetups, or just about anything else that will help you grow your local community. Look for more details on https://groups.drupal.org/florida soon.  

More Fun

While Drupal events tend to be very positive events for all attendees, we made the conscious decision to ensure that we maximized the enjoyment of our attendees while we kept the Drupal knowledge flowing. It was also very important to us that we make a positive first impression on those new to Drupal and attending one of their first Drupal events. We wanted folks to be able to leave the event with positive feelings for the Florida Drupal community. 

Networking at the after party.

To this end, we increased the fun factor in several ways. First off, we further "official-ized" our Friday night dinner gathering. Over the past few years, organizers and a few others have always gathered at Bubbalou's a local BBQ restaurant just down the street from the camp venue after prepping the venue for the event. This year, with the full-day trainings on Friday, we invited everyone to meet up at the restaurant for a pay-on-your-own dinner. This turned into a wonderful, casual evening for well over 75 people. The restaurant has a large indoor/outdoor picnic table eating area, perfect for networking. 

Suzanne Dergacheva with Skywalker

On Saturday, we set the tone early and put smiles on people's faces from the very start. We worked with the folks from Gatorland to have a professional animal handler and a friendly alligator named Skywalker on-hand to greet guests when they arrived. Many attendees went for a cuddle with Skywalker even before getting coffee. 

Druplicon chocolates

Additionally, we wanted to provide unique swag to our attendees. A former attendee of previous Florida DrupalCamps, Kathryn Neel, is now running custom chocolate business, Sappho Chocolates. We worked with her company to create Druplicon chocolates for all attendees. As part of the process, we funded the development of the custom molds for the Druplicon chocolates, so if any other Drupal event organizers want to order chocolates for their event, the molds are there for your use!

Finally, for the last Saturday session, we went with a single session of lightning talks. This ended up being one of the highlights of the weekend, as we had a some amazing 5 minutes talks. With most of the camp attendees in the room, it left everyone with smiles on their faces and provided a great transition to the closing session and after party. 

Sponsor Happiness

Most camp organizers always have trepidation about camp finances right up to the actual event. Sponsor needs have evolved as the Drupal community has evolved, and camp organizers have to evolve as well. Today's Drupal event sponsors are more focused on getting a return-on-investment from their sponsorship dollars than ever before, so it is up to event organizers to do everything they can to make that happen. 

By providing more time for attendees to visit sponsor tables as well as the opportunity for Platinum and Gold sponsors to receive an opt-in version of our attendee list, as well as all of the other "standard" sponsor benefits, the feedback from our sponsors has been very positive. Additionally, we gave Platinum and Gold sponsors the opportunity to place text ads in our emails to attendees leading up to the camp.

Achieve Agency logo

Our Platinum sponsor, Achieve Agency is a newly-formed Florida digital agency based in West Palm Beach. John Studdard, their COO (and formerly of Big Couch Media), has been a long-time FLDC supporter and attendee, and wanted to use FLDC as a vehicle to announce Achieve Agency to the community. As event organizers, we couldn't be happier that our top-level sponsor is a Florida-based organization. 

Featured Speakers

Megan Sanicki at FLDC17.

Keeping with our tradition of not having a single keynote speaker (mainly due to the fact that our venue's auditorium can't accommodate all attendees, we invited three featured speakers to this year's event. We were lucky to get our top three choices - check out their (recorded) sessions below:

Room for Improvement

As always, our post-camp organizer retrospective highlights a few areas we need to address for next year's event.

  • Have a printer on-hand for printing emergencies.  
  • Find a volunteer to arrange for food donations for left-overs.  
  • Figure out a magical solution for badges that will make everyone happy.  
  • Find a new official hotel: We had a fair number of complaints.  
  • Figure out a way to improve the slow service at the after-party.  

Quick hits

  • Camp attendance was a bit more than last year. Overall, we had 251 registered attendees. A bit more than 100 participated on Friday, almost 200 participated on Saturday, and about 100 participated on Sunday.  
  • Camp budget was about $18,000, the majority went to catering, but we also had significant costs for featured speakers and sprint leads travel and swag.  
  • We had a total of 17 fiscal sponsors which provided about two-thirds of our income.  
  • The registration fee for attendees was $35 ($25 early-bird), with an optional $25 individual sponsorship. We had 41 individual sponsors.  
  • Our camp organizing volunteers are way better than yours.  
  • We invested a bit this year in large signage that we can re-use in future years.  
  • Another change this year - volunteers got in for free (sorry this took so long).  
  • We had attendees from 9 countries and 19 states.  

Summary

What more can we say? Florida DrupalCamp 2017 was a huge success. Our volunteers are the best, our sponsors are the best, and the Florida community is the best!

Be on the lookout for an announcement about the dates for Florida DrupalCamp 2018 by joining our mailing list and following us on Twitter!

Jan 25 2017
Jan 25
Take your time concept clockMiriam Webster defines effort as conscious exertion of power: hard work

If you want to learn Drupal, you need to put forth some effort, and if you want to do it properly, get ready to exert some power for months, not days.  People ask us all the time if they can get a job right out of our Drupal Career Online program. The truth is, it depends on how much hard work you put in to get out ready enough for an internship or junior position. Whether it’s Drupal or anything else, learning something and being able to apply it well depends on how much you absorb and practice, both of which are best done over time.

Last summer, James Dennin wrote an insightful piece of advice for those seeking careers in coding for Fusion.net. It touches on a lot of the same issues with bootcamps that we have heard about for years from students who come to DrupalEasy Academy after disappointing experiences. While we don’t like to throw barbs, we like less the sad stories of lost dollars and time in unguided crash courses where people are seated in a room, immersed in videos and teamed with other, non-skilled newbies on trying learn Drupal. A 5- or 10-day whirlwind of information overload is seldom a successful learning experience.

Becoming proficient in Drupal is no cakewalk; it includes amassing knowledge, learning best practices and developing skills as part of a challenging learning process, whatever your process may include. Education experts recognize as many as seven different styles of learning, including:  Visual, Aural, Verbal, Physical, LogicalSocial and Solitary. Most people find a combination works best. For anyone, regardless of the learning style; taking the time to really soak it in and get some hands on experience is key. The bottom line is that Drupal takes time and practice.

For those who do well on the solitary route, Build-a-Module, which routinely supports students and alumni of our career training program, has a solid, comprehensive library of instructional videos that you can take your time to work through with a modest monthly subscription.  You can also check out Drupalize.me.

For those who learn better with a formal course or need to train-up a team; our Drupal Career Online program uses live instruction; a stackable-skill designed curriculum; practical exercises; and group learning.  We also provide resources like lesson guides, screencasts for every lesson, and help when you need it. In addition to all the great feedback we get from our students and all the great graduate case studies, we ensure our program meets accepted educational standards as a career program, so we go through an annual review to ensure we remain a licensed, post-secondary institution through the Florida Department of Education, Commission for Independent Education (see page 21 of the linked PDF.)  

We are committed to Drupal and developing awesome Drupal talent, which is why we cringe when we hear about drinking-out-of-the-firehose learning scenarios. It is also why we have been perfecting our course (yes even making it longer) over the past 6 years. Best practices and allowing students the time to soak up what they’ve learned, along with hands-on projects and expert-developer instruction are fundamental elements of Drupal Career Online. It includes 84 hours of live, online instruction over 12 weeks as part of the learning community of current students and alumni. The course covers practical projects and assignments, and includes 12 co-working labs and instructor office hours, which are available to current students and alumni every week. The Spring 2017 session begins March 13, with the deadline to apply March 6.  

For most, learning anything, especially Drupal, is a process that takes an investment of time and effort, not just from the students, but from those who endeavor to help them learn.  Don’t cheat yourself and risk wasted time by trying to save time. Whatever learning styles work for you, make sure you take the time and put in the effort to follow a logical path that builds knowledge and helps you get comfortable with key skills in the way that ensures your hard work leads to your ultimate success.

For more resources about becoming a Drupal developer, take a look at our Career Resources.  To learn more about our upcoming Drupal Career Online Spring session, sign up for one of our free Taste of Drupal online information sessions in February.

take your time concept clock Photos by Pond5

Jan 11 2017
Jan 11

Florida DrupalCamp 2017 logoWe’re taking it up a couple notches this year down in Orlando for the 9th Florida DrupalCamp! We're expanding in every dimension we can find - highlighted by an opening day (Friday) of full-day workshops followed by two days (Saturday and half-day Sunday) of sessions!

Amazing Trainings

In previous years, we’ve had concurrent trainings on Saturdays and some sprinting on Sunday. This year, we changed it up: Friday will be a full training day including workshops on:

  • Beginning React JS - taught by John Tucker
  • Docker for Development with Drupal - taught by Lisa Ridley  
  • Introduction to Drupal 8 - taught by DrupalEasy's own Michael Anello  
  • Introduction to Drupal 8 Theming - taught by Suzanne Dergacheva
  • Introduction to DrupalVM - taught by Ben Hosmer

The best part is that trainings are included with the price of the ticket (now $35). You sign up for the training when registering. Space is limited, however, so register soon!

Three Phenomenal Featured Speakers

We have three amazing featured speakers this year!

Many More Extraordinary Sessions and Speakers

We have over 30 sessions already submitted with several weeks to go until the deadline. We still need more. Check them out and submit your session soon.

Kick-A** Weather

Orlando in February. Sunny and warm :)

The Absolute Best Sponsors Ever

It's true, we have the best group of sponsors money can't buy! We're crazy-happy about having Achieve Agency as our top-level Platinum sponsor. This newly formed South Florida shop is looking to make a big splash in the community, and we're happy that we can help introduce them to everyone. 

Combined with Johnson & Johnson, devPanel, and Digital Echidna as Gold-level sponsors as well as all of our other amazing supporters (including DrupalEasy!), we're excited to bring you the biggest and best Drupal event you've ever seen (not to mention a few fun surprises!)

Lots More Sensational Stuff!

From a new logo, great catering, t-shirt, giveaways, and even an integrated video game easter-egg on our website, there’s lots to be had. Don't miss it!  Register today or regret it for the rest of 2017!

Oct 14 2016
Oct 14

The 9th annual Florida DrupalCamp (FLDC) will be held February 17,18, and 19th, 2017 in Orlando, Florida; DrupalEasy is proud to be a sponsor.

We’re super excited to announce Megan Sanicki as our second featured speaker. Megan is the Executive Director of the Drupal Association (DA), and will talk about all the things that the DA does to promote and serve Drupal.

Megan joins Helena Zubkow as a featured speaker for FLDC. Helena is an accessibility expert for Lullabot and will be leading a double-length session on how to make Drupal sites accessible. The third (and final) featured speaker will be announced in the coming weeks.

Bigger and better!

FLDC is expanding to 3 full days of activities in 2017. On Friday, February 17, we'll be offering several free training events (details coming soon) as well as sprint opportunities and a social event. Saturday, February 18 will be a day full of sessions followed by an afterparty. Sunday, February 19 will include a half-day of sessions and additional sprints.

Sponsor Florida Drupalcamp!

FLDC is accepting sponsorships. More information can be found at https://www.fldrupal.camp/sponsors/become-sponsor.

Session Submissions are Open!

Have new Drupal or web development knowledge that you’d like to share? We’d love to have you! Submit your session proposal at https://www.fldrupal.camp/sessions

Oct 03 2016
Oct 03

Really good content in the wrong format.

Drupal 8 Development Cookbook cover imageDrupal 8 Development Cookbook, written by Matt Glaman is full of useful information about Drupal 8 site building and development - and a worthy addition to anyone's Drupal library. Unfortunately, the "cookbook" format of the book seems to subtract, rather than add, to the usually well-explained concepts throughout.

The book covers an impressive array of topics: Everything from setting up a local environment to many of the technical details of the Entity API. No matter what your skill level with Drupal, there is likely to be something in this book of interest. Having been a Drupal professional for over ten years, I found the chapters on plugins, configuration management, the Entity API and web services especially interesting and educational.

Each chapter (there are 13) includes an often-too-brief introduction, followed by several "recipes." Each recipe includes several sections, including "Getting ready," "How to do it…," "How it works…," "There's more…," and "See also." While the How to do it… sections usually contained the bulk of the narrative, I often found myself wanting more details in the How it works… section. Additionally, I felt that each recipe often didn't have an adequate introduction. The crazy part is that the information I was looking for was often in the How it works… section - presented after the How to do it… section. I think this will lead to some initial confusion by readers asking themselves "why am I doing this?" until they read the How it works… portion. Usually, all of the information was there, just not in the right order (for me at least.) This is especially apparent in the "Plug and Play with Plugins" chapter where I found the How it works… sections more valuable than the How to do it… sections. They really would have been better leading off each recipe.

The author clearly has a firm grasp of the material. This usually shines through in most of the recipes, but there are times in the book where I think the author assumes the reader has a similar level of knowledge - which leads to some disconnects in the narrative. One example of this is the "Creating a custom content type" recipe. There is very little introduction, and I feel that it assumes the reader has a firm grasp of the power of content types (and fieldable entities, for that matter.) This, and several other recipes would benefit greatly from beefed-up introductions (including Features, text formats, some of the Front-end recipes and plugins [especially explaining why we use annotations.])

The recipes also vary widely in their complexity. I'm not sure this if this is a good or bad thing, but perhaps some sort of "complexity level" rating should have been applied to each one to give the reader a heads-up. This is illustrated well with the fact that the plugins chapter assumes the reader has a firm understanding of object-oriented PHP. Granted, I don't expect the author to write a primer on the topic, but a warning in the introduction, or aforementioned complexity level, would have helped smooth the transition into this chapter.

As one example of the format forcing things to be out-of-order, the book begins with the assumption that the reader has a local development stack installed, which is not an unreasonable assumption. But for readers who are new to local development environments, after the recipe to install Drupal 8, in the There's more… section, the author presents valuable information about how to create a database and a database user. There is no mention of this material prior to the How to do it… section. I can easily imagine a scenario where a reader is attempting the recipes in the order they are presented without reading ahead, and being extremely frustrated until they find the There's more… section. A mention of it earlier in the chapter would go a long way here.

The book does a really nice job covering topics I didn't expect to see - including DrupalVM, Entity Reference Views displays, a thorough explanation of a module's .info.yml file and routing files (who knew you could validate a route name with RegEx right in the .routing.yml file!) There is a really nice chapter on configuration management (although more of an introduction on content vs. configuration would have been extremely useful) and Entity API.

For Drupal 7 developers moving to Drupal 8, "The Entity API" chapter is worth the cost of the book. This chapter solidified and extended the knowledge I already had. Its introduction is solid and the chapter includes examples for both content and configuration entities. While it suffers from some of issues I've already mentioned (great content, wrong format,) for the most part it overcomes these challenges and goes much deeper into the topic than I had hoped. Well done!

At the same time, the book also covers a few topics in places where I thought it was a little too aggressive - having a "Running simpletest and PHPUnit" recipe in chapter 1 is a good example. In addition, I believe I spotted a few bugs in the book - both in the narrative and in the code samples - I've forwarded them to the author. Also, in some chapters, the author is writing about a moving target. There are more than a few places where he is forced to reference active Drupal.org issues. As these issues are resolved, recipes may spoil (food pun!)

There were more than a few recipes that involved custom module development; all of which are well-written, technically on-point, and will be extremely useful for Drupal 7 developers moving to Drupal 8. Since this is a book review, I have to pick on one point - all of the recipes were presented as if the developer is writing them from scratch. In reality, I've found the vast majority of Drupal 8 developers building custom modules for clients take full advantage of Drupal Console's "generate" command. While the author does formally introduce this in the last chapter of the book, it feels like it's not in the right place. By introducing it earlier many of the recipes could be written to take advantage of it.

Who would I recommend this book to? If you're a Drupal 7 developer looking to learn Drupal 8 development, this book is a great resource. While there are several introductory and site-building chapters that won't be very useful to you, the more advanced chapters provide (usually) adequate background information along with practical examples (ahem, recipes) to get you going. Would I recommend this book for beginners? If you have a solid PHP background, then yes. In my opinion, the author is more than capable of writing an intermediate-to-advanced Drupal 8 development book - leave the introductory stuff to someone else.

Sep 14 2016
Sep 14

Chaos Tools Blocks module

While working with one of our project coaching (see below for details) clients recently, I was asked to show their developer how to override the default user profile display page with a custom Panels layout.

In Drupal 8, the process a bit different than in Drupal 7, but the main concepts are the same. We want to use the Page Manager module to override a particular existing system path ("user/{uid}", for example), then create a variant that uses Panels as the builder. The custom layout is created (quite easily) using the Layout Plugin module.

If you were just creating a standard landing page (and not overriding an existing system path), you'd have all you need at this point, just place blocks in the Panel and you're done. But, when you're overriding something like the user display page (or a node display page), you're probably going to want to place fields attached to the user entity in the panel as well. There's a couple of steps required to make this happen.

First, you'll need to create a new panel context for the entity whose display you're looking to override. This was something that was provided by default in Drupal 7.

Second - and this is where the non-obvious solution comes in - there's another module that must be enabled to get access to the fields. The "Chaos Tools Blocks" module (obviously, part of the Chaos Tools module provides each of the entity's fields as blocks. So, when you are adding content to the panel, all of the entity's fields are available through the "Add block" button.

As mentioned previously, we offer project coaching to clients as a way of guiding and training developers on the organization's own projects. Rather than a traditional training course where most of the curriculum is pre-determined, our project coaching clients receive customized training and best-practice guidance during the development phase of their projects on an as-needed basis. This allows the organization's developers to build sites with confidence knowing that they're getting a solid foundation while they're still in the learning phase of their Drupal journey. Contact us for more information.

Jul 28 2016
Jul 28

DrupalEasy training globe image DrupalEasy is proud to announce another cavalcade of training events in the coming months, both online and in-person. We have numerous opportunities for you to take advantage of our proven Drupal 8 module and theme development courses as well as our flagship technical education program for those seeking comprehensive training to become developers; the 12-week Drupal Career Online.

The primary instructor for all courses is Mike Anello (ultimike), an expert instructor and experienced, practicing Drupal developer. All DrupalEasy training is taught by only expert developers to ensure that lessons are taught accurately, reflect best practices, and draw on how real-world Drupal sites are built. Mike has been active in the Drupal community for over 10 years, is a core contributor, a Drupal Association member, and one of the leaders of the Florida Drupal Users' Group.

12-Weeks of Career Training
Drupal Career Online starts on September 26, and runs every Monday and Wednesday afternoon from 1-4:30pm EDT. In addition, there is a 4-hour co-working lab, which is scheduled by the students. Class is held online using GoToMeeting, and use of webcams and microphones keeps the classes highly interactive, with instructor and student-led demos and discussions. The live online classes are supplemented with reference and lesson-guide handouts, as well as screencasts that cover each and every lesson. Each student is assisted by a community mentor to help kickstart their personal Drupal network. Our goal is to provide the most holistic, sanely-paced, best-practice-focused, long-form Drupal course in the world.

Interested in learning more about 12-week Drupal Career Online course? We are offering two free Taste of Drupal webinars that outline the entire course, set expectations, and give potential students the opportunity to ask questions. Past students have included Drupal newbies, hobbyists, and content admins looking to learn how to become full-fledged Drupal developers.

5 Options for D8 Theme and Module Development

First, if you're headed to DrupalCon Dublin, we're excited to announce that we've been selected to be one of the official training providers! We'll be offering our Introduction to Drupal 8 Module Development workshop live, and in-person. You'll learn through our stellar curriculum, and have follow-on access to all of the handouts and screencasts, with the added bonus of the synergy (yes, we just used that word) of a live classroom.

We're also offering the popular Introduction to D8 Module Development online, as well as our Introduction to D8 Theme Development workshops (https://www.drupaleasy.com/training/workshops/upcoming) multiple times in August and September. The module development workshop is 8 hours, split over two half-days, and teaches the fundamental concepts of Drupal 8 module development, including using Drupal Console as an aid for module development. Our theme development workshop is 12 hours long, split over three half-days. This super-sized workshop teaches the fundamental concepts of Drupal 8 theme development including building template files with Twig, creating custom subthemes (using Bootstrap as the base theme), and setting up a professional-level front-end development toolchain using Node.js and Gulp. Both of these courses include a live instructor, PDF handouts, and screencasts for all in-class examples.

We are committed to providing the highest quality Drupal talent development, from beginner to advanced programs; which is why our trainings work. We've taught the 12-week DCO ten times (including twice as part of Acquia U) and our 1 and 1.5 day workshops always get great reviews, just see what our graduates have to say!

Jul 11 2016
Jul 11

IPERS.org logo

When it comes to serving their constituents with effective online access, the Iowa Public Employees' Retirement System keeps getting it right.

From the time IPERS was first deciding to shed their Dreamweaver framework a few years ago for something more robust, to ensuring that they have well-trained internal Drupal talent; the IPERS Application Programming Services and Communication teams rocked the process and aced the outcome by sticking with best practices.  

The IPERS APS and Communication teams chose Drupal through an extremely efficient process, focused on what other agencies had already put in place, how the transition went, and how the new framework was working out. The solution would of course have to be cost effective, ensure that the needs of the agency and their 700 daily users were met, be implemented in a timely way, and utilize the ability of their internal team to deliver and maintain high levels of service for years to come.

Carla StonerCarla Stoner

Carla Stoner, who has been with IPERS for 19 years, is the APS team member directly responsible for the technical function of the web site and coordination with the Office of the Chief Information Officer. APS and the Communication teams streamlined their selection process, using the experiences and examples of other Iowa agencies that had already upgraded their web sites. Once they narrowed down the field of potential frameworks, a final demo of DotNetNuke by a fellow state agency made Drupal the clear choice. They contracted and worked closely with an outside consulting company to develop the new IPERS site, which went live in the summer of 2015.

While the new build was going on, Carla was made aware of DrupalEasy’s Drupal Career Online program. “My supervisor was the one who found the DrupalEasy training course for me,” she explains, “He wanted a type of training that would have substance and not something that would last only a week and be crammed with spoon-fed work exercises.”

The DCO is long-form training with integrated instruction, an actively-engaged expert teacher (MIke Anello; ultimike on Drupal.org) focused on student learning, a built-in learning community, and comprehensive learning and resource materials. The program emphasizes Drupal best practices and community participation.

“My supervisor and I were both impressed with the length of the course, knowing that there would be a lot of material covered. We also liked the idea of all the ‘hands on’ experience…” she recalls. With this in mind, they decided to wait on formal training for Carla until her schedule allowed her to really engage. After the transition to the new site, she was encouraged to devote the 11+ hours per week to the 12-week session of the DCO that began that September.

“I had zero background in Drupal, but had used Dreamweaver, which gave me exposure to HTML and CSS,” she said. She continued, “...All of the topics covered in the DCO are very relevant to my work.  Even though our test and production environments are setup a bit differently from the norm (Drush and Git aren’t used as prevalently), learning these basic tools of Drupal have increased my skills for when I do get to use them.”

She added, “The DrupalEasy course is laid out in such a way that it keeps building on each segment. You don’t just learn it once and forget it.  Michael has you continually utilizing what you learned and then reapplying it... I also enjoyed the “community” we developed amongst ourselves, the classmates.  We helped each other.  Michael fostered an atmosphere that made learning fun... It helped build camaraderie.  I still feel that same camaraderie to this day.”

Carla’s learning also continues. “My DrupalEasy class ended last November (2015) and even now as I come across a request to change our website, I remember back to when Michael taught us how to accomplish that.  And if I don’t remember, I can always review the very handy screencasts he has done.”  She is also among the DCO alumni who take advantage of Mike’s open office hours every Thursday afternoon.“We all try to help each other. Even though I am by no means an expert...there are times that I feel I’m making a helpful suggestion or can see as I’m watching Michael demonstrate how to solve a person’s issue…,” she concludes.

IPERS transition to their Drupal site, starting with the selection of the framework, into the site development and continuing on with internal staff development demonstrates the effectiveness of using tried and true best practices.   They looked at their needs, found the most cost-effective solutions, and committed the time and effort to ensure the best possible outcomes. That’s effective government.

If you would like to learn more about Drupal Career Online, you can attend one of two Taste of Drupal informational workshops coming up in August and September. 

Jul 05 2016
Jul 05

Whether you are with an organization switching to Drupal, or you have chosen to make Drupal the focus of your web developer career, your future can be a lot of different things depending on your goals, your focus and your personality. It’s never easy shifting your career, and with Drupal, there are no official, defined developer career recipes to guide you.  

The good news is, the ingredients are out there. Within the open-sourcey, especially welcoming, social melting pot that is the Drupal Community, there are a lot of career resources, organizations, individuals, advice and success stories that you can draw on to help you make good choices.  Here are a few tips to add to the mix. 

Learn early on to do things the right way

Drupal is to web development what snowboarding is to winter sports.  They say that it takes a lot longer to learn to snowboard than to ski, but once you get the hang of it, you learn advanced things more quickly, and are able to do a lot more (and have a lot more fun) on a snowboard than you could on skis.  

Investing a good amount of time and focus on learning the foundations of Drupal and developing habits based on best practices will really help you reach proficiency, and let you go farther, faster in the long run. The key is making sure you take the time to learn best practices, and don’t go for shortcuts before you’ve got the basics.

Another part of learning the right technical skills is to learn key elements of Drupal, not just in the right way, but in an order that will give you stackable skills. Getting key concepts down at the start will help to not only build your abilities, but feed your confidence.  At DrupalEasy, we call them the Big 5:

  • Content types

  • Users/roles/permissions

  • Taxonomy

  • Blocks/regions

  • Menus

We feel that mastering these concepts is so important, that in our long-form career training program, the curriculum is designed with examples and excercises that specifically draw on the Big 5 as solutions over and over to ensure that they become second nature for every participant.

Don’t be shy, even if you are

The Drupal Community is unique. There is always an opportunity to help, and there always seems to be someone to provide a little guidance or an answer when you have a question.  Make sure you become part of Drupal.org, find an IRC channel that you feel comfortable with, and go to local meetups.  

We really can’t overstate how key getting involved in the Drupal community is to your technical and professional success.  Once you register on Drupal.org, you can access myriad ways to get involved and help with the Drupal project. Helping to test, sorting out issues and contributing to documentation will not only help build your skills and confidence, it will build your reputation.  Even before you are ready to contribute on the technical side, you can join your local Drupal Users’ Group and start by attending, meeting others, and eventually helping to organize events.

Drupal friends and mentors really come in handy as you progress along your career path, more so than in other industries because of the nature of Drupal. We all rely on each other to build, enhance, fix and grow the project, so the more we work together, the better the project, and the better we will be as Drupal professionals.  We feel really strongly about this as well, which is why we require all of our Drupal Career program participants to get involved, and we provide everyone  a community mentor to kick-start their community efforts from the start of the program.

Just do it, and do it again, and again

With anything, if you want to master it, you need to practice, and practice a lot. Build sites for fun and experience. Like snowboarding, it is especially hard when you first start out, but if you stick with it, and take the struggles as opportunities to learn and get better, you will surely succeed. You’ve also got a lot of potential help and guidance through the community (since you have already taken that advice to heart,) so take advantage of it early on and be prepared to give back when you can.

Our training programs stress this concept of practice, repetition of key skills as you learn more and more, as well as different methods to help you learn them. We are strong believers in building your skills and really understanding Drupal, and that means live instruction by practicing experts, lesson guides, examples, exercises and screencasts to help you soak in the material in different ways. However you learn, take advantage of resources, find different ways to absorb and engage, and practice, practice, practice.

If you would like to learn more about how to succeed in Drupal and our long-form training program, you can sign up for one of two, no-cost Taste of Drupal workshops coming up and explore the resources below. 

Taste of Drupal free workshop 

Drupal Career Resources 

Drupal Career Online Program

Drupal Events Calendar

Drupal Groups

Jun 25 2016
Jun 25

Mastering Drupal 8 Views book cover

Gregg Marshall's Mastering Drupal 8 Views is one of the (I can only assume) many Drupal 8-focused books that will be released in the coming months. It is a very good deep dive into many of the hidden corners of the Views module, albeit with an interesting format. Not completely structured like a typical how-to software book, Gregg takes a bit more of a novel approach (pun intended) - he takes the reader on a journey through the Views module through the eyes of Lynn, a small business owner (Lynn's cat and Drupal consultant also have prominent roles). While some readers might find the story-ish elements distracting, they add a certain degree of warmth to the book - something I can only assume a subset of readers will more than appreciate.

The author does a nice job of setting the stage, identifying the intended audience for the book, and speaking directly to them (through the book's characters). There are sections of the book that may cause confusion with this structure, on several occasions I found myself reading long, multi-paragraph sections that I didn't immediately realize that a character was speaking, and not the author. It seems that the use of quotations to indicate when characters were speaking was not consistently applied.

While the technical content of the book is often well-written and clear, there are some places in the book where things seem out-of-order - none more so than the first lesson diving into the Views "settings" page - something that most people new to the subject don't need to consider until they need to modify the (very sane) default values. Another example early in the book has the author creating a new view "display" prior to a full explanation of what Views display are.

There are, however, many areas of great explanation on topics that I don't recall ever seeing in other Drupal-related books. Sections on the new "entity reference" and "REST export" display types stood out in the first few chapters, as well as some of the best explanations (and details) on the "table" format, and field rewrites (more on this in a bit).

There are several lessons that have starting points that aren't necessarily considered "best practice", including one that has the reader cloning the admin/content view as a starting point for a public facing view. In my opinion, the reader would be better served by starting a brand new view using the Views "wizard" interface. As a stickler for best practices, there were several things in the book that made me cringe a bit, including the use of the (outdated?) GMap and Location modules (instead of Geofield-related modules) and (even more so) the use of the admin area's "Install new module" functionality.

I found the discussion and lessons around contextual filters to be extremely effective. The story-ish nature of the book allowed the author to almost naturally introduce a problem that is elegantly solved with contextual filters. Along with relationships, contextual filters are often one of the major stumbling blocks in learning Views, and this book does as good a job as anything else I've read and taking the reader down in the deep, dark recesses of it ("Default value" options included!) The chapter on Views relationships is similarly structured and just as effective.

This is perhaps one of the only Drupal books I've read that purposely sends the reader (in this case, the main character as well) down a dead-end in order to introduce a new topic. I think that many readers will find this comforting, in that it allows the author to introduce a new topic in order to direct the reader to a solution.

As a big fan of display modes, combined with the fact that they are much more visible in Drupal 8, I hoped that the author would utilize them more often in the various lessons (instead of relying on adding fields to most views).

The book really shines in chapters that normally are only a small section in other Drupal resources. There is an entire chapter on field rewrites, and it is wonderful. The author takes Lynn and the reader through various examples, each exposing a new aspect of field rewrites. For anyone who doesn't dare dive into this section of Views field configuration, this chapter alone is worth the price of the book.

The chapter on all the settings in the "Advanced" fieldset is also something that the author covers extremely well. In most Views references, many of these settings are glossed over, but this book provides an almost ("aggregation" isn't covered as deeply as I hoped) complete reference to all the various available settings.

While the vast majority of the examples in the book are well structured, many of them depend on content types and other information architecture that exists on "Lynn's" site. While details of the information architecture are provided in an appendix, it would be very helpful for the author to provide them via GitHub or some other electronic mechanism to readers. Otherwise, it seems like a tedious and error-prone process for readers to recreate the information architecture on their own in order to follow the examples in the book.

The author does a nice job of walking the reader through the use of several Views-related contributed modules as well. For my taste, I think there should have been just a little more explanation about how various contributed modules fit together with Views. As an example, the fact that Views Slideshow provides a new display plugin is glossed over. I think it would serve the readers well to specifically mention that many Views related modules are simply plugins for various parts of the Views infrastructure. This would provide readers with a higher-level view of the Views ecosystem. That's a bit of a nitpick though, as this section is really, really solid.

One of the last chapters in the book covers theming views, and I think it doesn't go into enough details and/or examples. The section on adding CSS classes to various parts of a view is very useful, but the section on overriding template files feels incomplete.

Overall, this is a welcome addition to the Drupal family of books, and one that I can honestly recommend for users that feel like there are aspects of the Views module that are still a mystery to them. The novel-like structure of the book normally doesn't get in the way of the lesson, but for readers who normally don't read technical books front-to-back (instead cherry picking only chapters of interest), it might be a bit distracting. While this is properly identified as a Drupal 8 book, much of the content is also valid for Drupal 7, including some of (in my opinion) the strongest chapters.

Jun 04 2016
Jun 04

Sample Kint output

Drupal 8's new theming system is a thing of beauty. As part of the massive changes to the Drupal 8 (front- and back-end) developer experience, the Devel module for Drupal 8 comes with a new variable inspector. Say goodbye to Krumo, and say hello to Kint. Like its predecessor, when you install the Devel project on a Drupal 8 local environment, you automatically get the Kint module as well (like Krumo, there are no additional downloads). Using Kint is similar to using Krumo, where in Drupal 7, any dsm($variable_name) or dpm($variable_name) call automatically used Krumo to display variables on the page in a way that made it easy(ier?) to dive into the many Drupal PHP arrays and objects. In Drupal 8, kint($variable_name) can be used to output any variable - this works in template files as well via {{ kint(variable_name) }}.

It took me a few weeks to get comfortable with Kint, mainly due to one small interface thing; clicking on the "+" icon in a Kint output recursively opens all the arrays and objects. Depending on the variable you're Kint-ing, this could result in a lot of output to sort through (and, depending on your machine, browser, and site configuration, it could take more than a few seconds to fully render).

Open all the Kint arrays and objects.

After a few weeks of instinctively (and incorrectly) clicking on the "+ button every time I used Kint, I've now retrained myself to utilize it in a much more efficient manner.

  1. I almost never click on the "+" anymore. Rather, I click output anywhere other than the "+" to open just that portion of the output.
    Non-recursive clicking in Kint.
  2. I download and install the Search Kint module whenever I download and install the Devel module for a local environment. This provides an almost-too-convenient-to-believe search box with each Kint output that makes finding things almost trivial.

    Using the Search Kint module.

Using Kint efficiently is one of the skills that every Drupal 8 developer should have. Combined with an interactive debugger, there's virtually nothing that can't be easily discovered when a developer can wield both of these tools.

Learn more about Drupal 8 module and theme development debugging by attending a DrupalEasy workshop!

May 27 2016
May 27

We’ve really been busy here at DrupalEasy updating our curriculum and adding some training programs that we think will help get people leveraging the new awesomeness of Drupal 8. After a few times out at Drupal events, and our upcoming gig at Drupal North in Montreal with Introduction to Drupal 8 Module Development on June 15, we’ve decided to go broader. We’re going new school, with online sessions of these D8 workshops in June to extend the reach beyond camps and 'cons.  

If you are looking to get up to speed with Drupal 8 module development and/or theme development, two online afternoon sessions live, at your desktop are coming up:

Introduction to Drupal 8 Module Development

  • 2 Afternoons, Live, Online
  • Monday & Tuesday June 13 & 14;
  • 3:00 pm - 7:00 pm EDT each day
  • Early Bird: $199. After June 6; $249
  • Register now

The Introduction to Drupal 8 Module Development workshop is designed for anyone with either knowledge of PHP or knowledge of Drupal 7 module development. The workshop takes users through the development of three custom modules demonstrating the basic principles and concepts of Drupal 8 module development. Students will be hands-on for the majority of the day, and will leave with confidence to start writing their own custom Drupal 8 modules.

Introduction to Drupal 8 Theme Development

  • 3 Afternoons, Live, Online
  • Monday, Tuesday & Wednesday June 20 - 23
  • 3:00 pm - 7:00 pm EDT each day
  • Early Bird: $199. After June 13; $249
  • Register now

The Introduction to Drupal 8 Theme Development workshop is our newest curriculum and it's super-sized! Through three half-days of training, you will learn about Drupal 8 core's new built-in base themes, Twig templates, theme anatomy, and a full-on front-end development toolchain that utilizes Node.js and Gulp. The workshop uses the Bootstrap base theme for two of its three main units, giving students plenty of hands-on time developing custom themes. Anyone with knowledge of Drupal 7 theming or a working knowledge of HTML and CSS will leave the workshop with skills to allow them to start theming Drupal 8 sites.

Pages

About Drupal Sun

Drupal Sun is an Evolving Web project. It allows you to:

  • Do full-text search on all the articles in Drupal Planet (thanks to Apache Solr)
  • Facet based on tags, author, or feed
  • Flip through articles quickly (with j/k or arrow keys) to find what you're interested in
  • View the entire article text inline, or in the context of the site where it was created

See the blog post at Evolving Web

Evolving Web