Upgrade Your Drupal Skills

We trained 1,000+ Drupal Developers over the last decade.

See Advanced Courses NAH, I know Enough
Feb 10 2021
Feb 10
Drupal 8 to 9 Migration

2020 was significant for web development — not just because of Сovid, but also because of the new version Drupal 9.

Since the new version was based on the same core as the previous one, the developers promise that the Drupal 8 to Drupal 9 migration will be smooth and fast.

Drudesk, our web development agency, has put together a guide for you on the migration preparation process from Drupal 8 to Drupal 9 to understand all the details and conditions.

Jan 07 2021
Jan 07

Since last June 2020, we heard a lot about Drupal 9. And you may wonder, should we do the update to Drupal 9?

Depending on you current infrastructure, the consequences won't be the same. That's why, our experts wanted to do this infography in order to give you some insights about you next Drupal project.

A project? A question? Don't hesitate to contact us: https://www.smile.eu/en/contact

Infography Drupal 9

Dec 16 2020
Dec 16
Drupal modules to increase site performance

Do you want your site to be the first in the search results, make users feel comfortable using it, and get a high conversion rate? Just make it as fast as possible! 

Your website's speed is essential because, if the website is fast, users will visit it more often. Statistics say that if a user waits for 3 seconds and more, they will leave the website and never return. The most comfortable loading time for users is 2 seconds. You may ask:

Mar 21 2016
Mar 21

Last Friday, I gave the first in a series of front-end web development talks here in Taipei. There were 11 attendees as we discussed in length how to structure a site’s styles with CSS components and Drupal 8 naming conventions.

The success of the class was entirely due to the participants who were engaged and asked lots of questions to probe their understanding of the concepts and challenge me on things that seemed a bit off on my slides. We talked for over 3 hours; here are some highlights:

We started the evening by going over the core front-end development principles: progressive enhancement, accessibility, front-end performance, re-use, and automation. When we talked in detail about the layered approach for progressive enhancement, they noticed right away that it implies accessibility. Very astute! Now that I’ve had a few days to reflect on this, I can see a general pattern. Not only does progressive enhancement imply accessibility. Accessibility implies front-end performance. Front-end performance implies re-use. Re-use implies automation. They are all inter-related.

A few of the participants had used Angular.js, so we discussed how Web Components (the W3C spec), React.js components, and other framework components are slightly different than CSS components. Those components require a specific HTML element that contains any other markup; this forms a strict HTML structure that is always used when the component is used. CSS components, on the other hand, have a strict structure of class naming, not of HTML elements. The structure of our CSS component, e.g. .the-component, .the-component__an-element, etc., should never imply an HTML structure because they could be applied to different HTML structures. The classic example of this is the .button CSS component which can be applied to inputs (), buttons (), and links ().

They were amused by my drawing skills when I showed them my example CSS component: flower power.

When they saw my .flower__bed element, they asked how I would handle adding a .tree component that could also use a planting bed. Great question as it shows a very typical scenario in web development. I built the original .flower component with a simple initial requirement: the website only has one component. Now they were saying the requirements have changed; we have a design system with multiple components, a flower and a tree. Changing requirements on projects is natural. In this case we just need to do a simple re-factor. The .flower__bed probably needs to be refactored to be its own component, a .planting-bed component that can contain a .flower or a .tree.

They loved the class name of shame, .channel-tab__guide__upcoming-video__info__time. That name implies all sorts of HTML structure that makes the component difficult to refactor. .channel-tab__video-time is more flexible and much simpler.

One participant asked about an example class name I had shown, .the-component--modifier__an-element and we discussed how that should probably be replaced with .the-component.the-component--modifier .the-component__an-element as it makes it easier to create compose-able modifiers (e.g. .button, .button--big, .button--red can be combined to create a big button, a red button or a big red button.)

I love discussions of the ideas I present because I gain valuable insight from the participants. Thank you so much to all who attended!

By the way, if you missed the class or don’t live in Taipei, I’m available to teach your organization remotely or in person. Just contact me!

Sep 19 2014
Sep 19

After hours of searching Google, lots of trial and error, and a bunch of grumbling, I had a breakthrough and finally figured out how to get Source Maps to work under Chrome and Compass. The problem is that this functionality has been around for over a year in various forms in the pre-release versions of Sass and Chrome. As such, many of the posts I found were out dated and didn't work with the current, stable versions. So this post is partially to document the process for myself (and a small victory lap!), but hopefully someone else will get something out of it.

So with that said: As of Sept 19, 2014, with Chrome 37 stable, Sass 3.3.4, and Compass 1.0.1; here is how I did it!

Compass

The part I stumbled with the most was getting Compass to kick out the required map files and the required comment in the resulting CSS files. The breakthrough was finding this article (http://chillco.com/blog/setting-sass-and-compass-source-maps) by Tommy Keswick, from July 2014. This was the only article I found from 2014 on the matter!

Simply adding sourcemap = true to the config.rb did the trick. For a more technical approach, sourcemap = (environment == :production) ? false : true would only produce maps during development. This addition alone is all that is required to display the source Sass file in Dev Tools, rather than the generated CSS file.

Update: If you happen to be using something other than Compass to compile your Sass, have a look at Compass Sourcemaps over at WDW. It covers using sourcemaps with Gulp-Compass, Gulp-Ruby-Sass, Grunt Contribute Compass, CodeKit2, and the command line. 

 

Chrome

Chrome has been supporting Source Maps for a couple versions now. So if you have a current, stable version, you are good to go. There is no longer a need to use Chrome Canary or enable any experiments.

A Workspace needs to be setup in Dev Tools to map back to the local development enviroment. In the case of Drupal, this would be the root of your theme.

Chrome Workspace Setup

The Workspace gives Chrome permission to the local file system, and also displays the local files in the Sources panel of Dev Tools.

Sass file in Sources panel

The final trick is to now tell Chrome how the files map together. Find a Sass file under the remote tree and map it to the local one.

Select Map

Chrome will scan the Workspaces and look for the best matches. Select the correct one.

Select local file to map to

It is only necessary to map one file, Chrome will figure out the rest. The Dev Tools will need to be relaunched.

Now clicking the name of the source Sass file in the Elements panel will open the file in the Sources panel for editing. CTRL+S will save the edits to disk, and if Compass is watching, generate a new CSS file with the change. For bonus credit, if LiveReload is also running, the browser can automatically refresh with the change also.

Jun 04 2014
Jun 04

Currently Drupal core does not offer any hook to do actions after a node/entity is inserted/updated/deleted in Database. So for example you can not send an email mentioning the node after the node is inserted because Drupal uses SQL transactions and the node is not yet fully written to database when hook node presave is called so if for any reason the transaction is rolled back, users will receive a false mail.

So Hook Post Action module introduces several new Drupal hooks to overcome this limitation
  - hook_entity_postsave
  - hook_entity_postinsert
  - hook_entity_postupdate
  - hook_entity_postdelete
  - hook_node_postsave
  - hook_node_postinsert
  - hook_node_postupdate
  - hook_node_postdelete

Feb 06 2013
Feb 06

For all Drupal's features, power, and flexibility, there is one area it has issues with - Content Migration. Getting content into Drupal in mass or from an older Drupal version can be brutal. So far each version of Drupal has had some sort of support for upgrading between versions included, but the chances of success can waver depending on how complex a site is and the modules used. Over the years a couple modules have risen to the challenge of addressing the migration problem, Feeds and Migrate

Migrating to Drupal 7 from Packt Publishing, and authored by Trevor James, tackles the often challenging task of getting content into Drupal from an outside source, and avoiding countless node/add forms. The books cover states "Learn how to quickly and efficiently migrate content into Drupal 7 from a variety of sources including Drupal 6 using automated migration and import processes."

Who this book is for

This book is for Drupal users, website managers, webmasters, content editors, or developers who have already installed and configured a Drupal site and understand its web-based administration; and who want to import data from other sources and websites into the Drupal framework.

This book will have little in terms of programming or code. Everything we do in the book will be configured easily by using the Drupal administration interface and module admin screens. We will look at some code briefly when we set up our Feature modules. You do not need to have any previous MySQL or PHP experience to work through these examples.

I want to call out "Who this book is for". Migrations aren't for the faint of heart and are a fairly advanced topic. I am not sure that is properly expressed above. "Drupal users" is pretty vague, and typically Content Editors are not behind the scenes folks, rarely will they be the people installing and configuring Drupal. However an intermediate site builder will do just fine with this book.

The book doesn't waste any time tediously explaining Drupal or how to install it, an advanced topic book shouldn't require it. Chapter 1, "Preparing Drupal for Content Migration", does touch on tweaking PHP memory, although focuses mostly on MAMP. The next 8 pages go on to detail how to install Admin Menu, CTools, Views, Job Scheduler, Features, Feeds, and Feeds Tamper. Considering the target audience should be familiar with Drush, this could have been shortened considerably, by omitting the install instructions and just explain why we needed the module and a brief synopsis. Note: The CSV file was not where the book said it would be in the sample files I downloaded. Instead it was in 0540OS_08/code/migration6/sites/$new_url/files/feeds/.

Chapter 2 is titled "Starting a Migration Path". It briefly talks about planning content types around the data to be imported, but focuses mostly on preparation for the supplied CSV file and less on theory. Again, some of the steps are more detailed than needed for an advanced topic book. More modules are introduced, without install instructions: Location, Location Feeds, Link, and References. A simple content type is created around the CSV, step-by-click-by-click.

Chapters 3, 4 & 5 deal with setting up, running and altering a Feeds import. This is the core of the book in my opinion. It does a good job running through things and explaining what is going on. Considering how detailed some of the earlier mundane steps where, there are a few things that feel a bit over assumed, but an experienced Drupaler should be able to figure them out. One thing that threw me was after preparing the import, "To run the import you need to go to the import URL for your site". This actually means /import. An Import link is also added to the Navigation menu, assuming you still have that block active - it is one of the first things I remove. A better wording or simply changing the sentence to "...URL for your site, 'mysite.com/import' ", would have saved me a trip the Feeds documentation and reading through the project documentation to figure it out. Reading the documentation on a module is always a good idea, but this feels like an oversight. Since the link isn't in the Admin area, it wouldn't have hurt to point out a somewhat irregularity from typical Drupal module admin structure.

Note: Feeds 2.0 has been released since the book was released, and the UI has changed slightly.  The book leads you to believe that referenced nodes will be created on import. Referenced Taxonomies do get created, but try as I might, I couldn't get the referenced nodes to be created. So my imports failed until I manually created the 24 Organization nodes for the referenced node type. Maybe I did it wrong, but there wasn't sufficient coverage on the topic to create reliable expectations on the outcome of this. 

While covering Feeds Tamper, there are two ways to access the settings mentioned. As of beta 4 there is a bug that breaks the link on the top of the Mappings page. A fix has been committed in the dev release, which also alters the UI some; Tamper now lives on a tab.

Chapter 6 covers packaging up the Feeds settings and Content Types with Features so they can be moved from a dev site to production.

Chapter 7 introduces the Migrate module as an additional method of importing content. It runs through importing the sample data included with the module. I am not really sure much is accomplished with this, as all the data is actually in the code included with the module. Migrate is a beast and requires coding to make it do anything and is considerably more complicated than Feeds. It also can be used to build on top of, such as the Wordpress Migrate module does later in the book. However the book doesn't go any deeper than that, and I suspect the only reason Migrate is covered as such is to provide a segue for the Wordpress Migration. However, for that reason this chapter should have been pushed back with the Wordpress chapter. Migrate is a beast, worthy of its own 100+ page book, so the dozen pages here really don't get you far. For a deeper look into Migrate, there is the Drupal.org community documentation and there was a technical session presented at Dupalcon Denver.

Chapter 8 really just rehashes the "official" method of upgrading Drupal 6 in place to Drupal 7. I was hoping there would be some alternative processes presented on doing this, as the upgrade can be quite troublesome for more complex sites. However unlike the official instructions included in the Drupal 7 UPGRADE.txt, the book introduces the use of the Upgrade Status module and the Drupal 7 CCK module as helpers. If you read enough about the upgrade on Drupal.org you will learn about these 2 modules, however UPGRADE.txt doesn't mention them. Upgrade Status is very helpful in getting a site ready to upgrade and identifying blockers. Fields moved into core with Drupal 7, instead of handled by CCK as in Drupal 6. So the Drupal 7 CCK module is used to convert them. I have ran through this upgrade a couple times with Upgrade Status and CCK before reading this book. The information on Drupal.org was a bit clunky and no where near as concise as it is presented in the book. I accomplished the upgrade following the steps in the book in record time!

Chapter 9 covers using the Wordpress Migrate module, which is dependent on the Migrate module. As such, swapping the Migrate chapter to follow the Core Upgrade chapter would make more sense to me. The chapter does a good job describing the process, unfortunately there are no sample files included. It would have been nice if the WXR export that was used in the book had been included in the code samples. I was able to pull an export from a clients existing Wordpress site and run through importing it into Drupal with decent success.

Conclusion

It is worth noting that both the Feeds and Migrate methods only bring over content, not menus. So there will still be work required to piece together the data imported.

The book does a very good job going through the process of importing with the Feeds module. It also covers the official D6 to D7 upgrade process in a very clear and easy to follow manner. The chapter on Wordpress to Drupal is a nice bonus. Additionally, it does that all in a manner that doesn't require coding skills. So an intermediate site builder should be able to handle them fine. 

However, the chapter on the Migrate module doesn't really do much beyond lay the ground work for the Wordpress chapter. Migrate really needs its own book, which requires considerable knowledge of coding and Drupal APIs. 

There are several screenshots that show content that isn't covered till later in the book, and a few places where it is assumed you have already created some fields and content types. With a little editing, omitting some unneeded tedious steps and shortening up the Migrate part, the book might have been reduced in size to about 100 pages.

Disclaimer

The copy of Migrating to Drupal 7 that was used for this review was provided at no charge to Scott Wilkinson of HaloFX Media LLC by Packt Publishing. However, no other compensation was received for this review and this review was published without prior review or any influence from Packt Publishing.

Aug 30 2012
Aug 30

Typically I find that learning by doing works best for me, and there are some subjects (Drupal) that lend themselves to this approach as well. Drupal 7 Development by Example sounded like just the ticket. Many of the big keywords are hit on while flipping through the preface. Initially this sounds great, but perhaps there are too many? This book appears to have all the right intentions, but maybe it bites off a bit too much?

Who this book is for

This book is for people who have some experience building websites and who want to learn to do so with Drupal 7. You should have experience with HTML markup, CSS, and jQuery. Experience with previous versions of Drupal would be helpful, but is not necessary.

The Book

Authored by Kurt Madel, the book was published in May 2012, about 2 months before I got it. It has roughly 340 pages of content, divided among 11 chapters. Glancing through the preface of what the book covers, the buz words flow: Module Development, HTML5, Theme Development, UX, Media, Views, SimpleTest and Features jump out. Additionally the preface covers some of the tools you will use: MAMP/XAMPP, GIT, Drush, Aptana Studio, Drupal core and a list of modules. The "Who this book is for" statement is also in there, I quote it for a reason. Also I would like to draw attention to the module list, which also lists the versions of the modules used, this is very important.

First Rant

Just 2 months after the book is published many of the instructions no longer work. This is because the modules have changed. While the preface list shows the version, it would have been very helpful to list the version when instructed to install a module. Then it would be fresh in the readers head that the version was different and a good clue why things don't look as described. Drupal is constantly changing and it's modules some times change at break neck speed, documenting them in print is going to have problems. Kind of the nature of the beast.

Moving On

Chapter 1 runs quickly through installing MAMP & XAMPP. I hate XAMMP, couldn't bring myself to do it (a subject for a future blog series). It does cover making a few tweaks for performance, so a few points there. Then onto installing Drush and Git, extra points for covering installing these on Windows. However when it came to installing Drupal I had to scratch my head. Drush is an awesome way to install Drupal, drush dl drupal. The reader is instructed to use Git to clone the Drupal project, while this works, it comes with a lot of baggage. As in EVERY version of Drupal from version 3 to version 8 and every point, beta and dev in between. Downloading with Drush brings down just the current stable release, which is 11.2mb and 1050 files. Cloning with Git grabs 61.8mb and 3023 files. There is a comment about how the Git method can make upgrades easy, but it is never explored. The process of installing Drupal is stepped through, like I would expect from a book that says you don't need experience with a previous version of Drupal, except the steps for copying settings.php and creating sites/$new_url/files are skipped. The chapter finishes out with Installing Aptana Studio and a quick introduction to Drupal.org. I had hoped some of the developer related features of using a full IDE would have been explored, however it turns out everything can easily be accomplished with Sublime Text 2, or even notepad.

Chapter 2 dives into Drupal with a new content type, and a lot of emphasis on schema.org. While interesting, it felt like we were losing focus and the schemas can get a little tedious, specially when they don't really relate specifically to Drupal. There is a discussion between, Core, Contrib and Custom modules. The t() function gets introduced, but kind of passed right by. This function is kind of a big deal in Drupal and probably should have got more attention. Some code gets thrown out there with instructions to modify some existing code, which is hard to follow. When instructed on creating our first module, the opening  tag is omitted from the instructions. The chapter wraps up by installing Views, building a simple block, and using Devel Generate.

Chapter 3 starts with a little HTML5 and microdata. I ran into some trouble with microdata, the descriptions didn't match with what I was seeing and then I started getting errors when the Microdata module was enabled. A new module is created for using a compound field. I had a lot of trouble with the code, and despite grabbing the example code from the website, the images stopped displaying.

Chapter 4 moves into themes, highlighting the Omega theme. Drush is used to create a base theme, but most all of the goodies in Omega are skipped over. Render Arrays get some attention and a decent first look. However the code used with hook_preprocess_node is kind of glossed over. For example twice the pages are used setting up Omega, as are used on the Render Array and the preprocess function. While Omega is a great subtheme, it didn't really add anything to the section. 

Chapter 5 focuses on UX, sort of. It programmatically creates a block with 70 lines of code, that could have been done with one line of HTML in a custom block. WYSIWYG is introduced. Then 18 pages and about 200 lines of code are used to create a custom Content Editable module. While the functionality is very cool, and a glimpse at what we might see in Drupal 8, it seemed way over the top for a beginner book, specially considering it was more javascript oriented and not so much Drupal.

Chapter 6 brings in the Media module and some major moving target issues. Additionally around this time my site melted down, Ajax errors every time I tried to add an image. Disabling all the custom modules didn't help. So to keep going I turned to Aegir and fired up a new site ( I love Aegir ). I pulled in all the example code from the website to get things back in sync, which is when I realized the sample code had some minor errors relating to CSS classes that needed fixing. There were a few minor errors in instructions and then I ran into a wall. We are instructed to use the 2.x branch of the Media module, which has some nice improvements over 1.x, but is under heavy development. The version is actually labeled 'unstable'. A lot had changed from when this chapter was wrote and now. Luckily Dave Reid, a Media module maintainer, was able to straighten me out in IRC. He pointed me to a Media 2.0 tutorial that explained how to set things up, drupal.org/node/1699054. Dave also expressed some concern about using the unstable version of Media in a book, it is just changing to fast right now. The Colorbox module is also introduced and has changed since the book was published.

Chapter 7 deals with various ways to get feedback. It starts with the core contact form and Webform. There is a nice exercise on adding some text to the core contact form. This is a great example of a beginner exercise, and functionality that should be in core! The Devel module is used to dig some info out of Webform so the HTML5 email type can be added to the form. This functionality was added to Webform in February to version 3.16. Once I realized why my code didn't match, I decided to move on. The middle of the chapter has a rather lengthy enhancement to the Colorbox module, which really has nothing to do with feedback. The chapter ends with the Fivestar module and creating a custom widget for it.

Chapter 8 is more about Views. Mostly basic Views stuff, but there is an example of creating a Views plugin. Although mine didn't look anything like the screen shot, even when using the sample code. The module list says Views 3.3, and the current version is 3.5, so not all the buttons and items are labeled the same. I was still able to follow along, but it was annoying at times. The chapter ends with promoting the Colorbox custom module to a full project and using the Coder module. Good stuff, but has nothing to do with the Views chapter it lives in.

Chapter 9 lets you know right off the bat that the content isn't all related, "Rotating Banners and Project Promotion". The banner part uses Views Slideshow and some custom CSS to tweak the display, good beginner stuff. Then it is back to our custom Colorbox module to prepare it for submitting as a full project. Not so much for beginners, although something to aspire to I suppose.

Chapter 10 is SimpleTest, which I have to say flew right over my head and think most beginners will be totally baffled by as well. While the SimpleTest module is in Drupal core, it really is a PHP framework.

Chapter 11 hits on Features, which probably should have come much sooner in my opinion. This is actually a pretty good run down on features. Bonus points. Features is just the kind of thing that new developers should be learning, and can be tricky to understand at first.

Final Rant

There are multiple times when steps are skipped in the instructions. There are no photos in the downloads, which may sound petty, except the instructions sound like we should have them. This book suffers from editing issues. I fully understand that things change from the time a book is started till released, but many errors would have been found by just running through the examples like a clueless newbie.

It may sound like I hated the book, I don't. However going back to that Who this book is for statement, it misses the beginner mark. In fact if PHP were in that statement, half my issues would go away.

Not all is lost

It is quite obvious that Kurt Madel knows Drupal development. I would say this is probably a decent intermediate book, that has some editing issues.

Disclaimer

The copy of Drupal 7 Development by Example used for this review was provided at no charge to Scott Wilkinson of HaloFX Media LLC by Packt Publishing. However, no other compensation was received for this review and this review was published without prior review or any influence from Packt Publishing.

Jun 22 2012
Jun 22

This is the second of three Packt mini books available on Drupal, the third (Drupal 7 Multilugual Sites) will be reviewed shortly. Initially the HackMonkey was skeptical if multi-site Drupal really required an entire book? The HackMonkey was a bit biased, having been using multi-site installs since the early days of Drupal 6. However, it quickly became obvious that this book was covering more than just the simple, "add another folder to the sites folder and name it as the url". The book has about 78 pages of actual content, flipping through the Preface and what the book covered, the question then became, can Matt Butcher really cover that much content in only 78 pages?!

This book is much more than just step 1, step 2, blah, blah. It really is a good book for both beginners and more advanced users. Installing multi-site Drupal is actually pretty simple, however many people really seem to get stumped by it. But once you understand it, it is a breeze. The install process is explained in great detail and brings clarity to what all the files and directories in "sites" are about. It will also help the beginner easily understand why there is a "sites/all" and "sites/$new_url". Too many instructions simply say use "sites/all", but don't discuss why or why not you might want to. On the advanced side, there are examples of sharing configuration, code, themes, users and content between sites; this isn't newbie stuff.

In many ways this book covers more than just multi-site topics, as it explains some of the structure that can trip up those new to Drupal, and rapidly get a user up and running (using the Vagrant install). The HackMonkey would really recommend this little book to all Drupal  beginners, whether multi-site is on their radar or not. It just hits so many simple stumbling issues quickly and efficiently. It would also be advised for advanced users looking to push multi-sites, wanting to share content, and users. There are also some good best practices stuff on backups, and warnings on when not to share between installs.

Here is a more detailed breakdown on what the book covers:

Chapter 1

This chapter starts off with a rather lengthy (felt like it) run down on various popular ways to host multiple sites on a single server or account, Drupal or not. While this may feel tedious to someone really interested in just multi-site Drupal, it could be a good intro for the true beginners not familiar with the various options. Half way into the first chapter there is a decent run down on installing a custom Vagrant profile with VirtualBox to actually build a multi-site install. The chapter finishes out with some basic configuration info on Apache & MySQL.

Chapter 2

Many books drone on about how to install Drupal and waste a lot of space on something that is too basic for the intended audience. This book is a little different, because how you install multi-sites in Drupal is actually fairly important. The process for installing Drupal and subsequent sites is nicely detailed. It is in this chapter that all the files and directories relating to a Drupal install are discussed, including domain named directories, subdirectories and sites.php. The chapter is rounded out by finishing the installs through the web interface.

Chapter 3

Things start getting more complex now, settings, modules and theme use in relation to multi-sites are discussed. There is good discussion on the how, why and why not you should do so.

Chapter 4

There is a lot of flexibility to running Drupal multi-sites, there also can be some extra headaches. Updating core, modules and themes takes a little extra work and planning for a multi-site install. Always Back Up is emphasized, as well it should be! This chapter will help you navigate the topic easily.

Chapter 5

Multi-site flexes it's muscles here, as advanced configurations are discussed. Several modules are discussed to make life easier, as some aspects of Drupal need a little help to work right in multi-site. The advanced topics of shared authentication, content, structure and search are covered.

Conclusion

The HackMonkey easily recommends this book for anyone just starting with Drupal in general, and further for anyone interested in running Drupal multi-sites. There is decent documentation on Drupal.org for setting up multi-sites, but it isn't as concise, or as well organized as the information in the book. You will be up and running much quicker with Drupal 7 Multi-Sites Configuration!

Disclaimer

The copy of Drupal 7 Multi-sites Configuration that was used for this review was provided at no charge to Scott Wilkinson of HaloFX Media LLC by Packt Publishing. However, no other compensation was received for this review and this review was published without prior review or any influence from Packt Publishing.

Jun 05 2012
Jun 05

Fear not the CLI, the Command Line can be your friend, trust the HackMonkey on this one! Drush is a perfect example of all that is wonderful about using a Command Line Interface with Drupal. To start off Drush can install Drupal & modules, clear the cache, enable & disable modules, backup sites, sync entire sites, wash the dishes, help you drink more beer, walk your dog, and make you look more attractive! Ok, it will not walk your dog or wash the dishes, but it can do all the rest and sanitize a database. That is kind of like washing the dishes, right? Don't believe me, fine. Check out this piece of classic Drupal cinema for more proof, Drush: More Beer, Less Effort. With all that extra efficiency you are bound to look more attractive to clients, right!

So now you understand why Drush is so awesome, and Packt Publishing's new book, Drush User's Guide is here to help you become a Drush Master. This book helps you jump right in and get going with Drush. It has lots of examples and has plenty for the novice Drupal chimp to the veteran Drupal gorilla. Authored by Juan Pablo Novillo Requena, a Drush contributor; it is also technically reviewed by Greg Anderson and Jonathin Araña Cruz, Drush co-maintainers and contributors respectively. There are no monkeys at the keyboard on this book.

The book immediately dives into installing Drush, it wastes no time explaining what Drupal is or the value of Open Source. You should have a grasp on those already. It goes into detail on how to install Drush on Linux, Windows & Mac and several different ways to do so. It is also up to date, covering Drush 5. Although a better job might have been done noting that some of the covered items are Drush 5 only. However, since the current stable release of Drush at the time of this review is Drush 5.4, it is a very minor point.

The book has 4 chapters and 119 pages, so it is easy to get through. The first 2 chapters cover installing Drush and the basic commands that any novice can master. The last 2 chapters cover more advanced topics.

All the basics like installing Drupal core, downloading modules, enabling modules, clearing the caches, and such are in these first 2 chapters. I was surprised Site Aliases weren't mentioned here, but they are covered in the third chapter, so keep reading even if you are a novice! While perhaps a bit on the advanced side, variables are also covered in the second chapter. Working with variables at the command line with Drush is a really powerful skill, and can save the day if you have a set variable cause a white screen. The Monkey did learn a valuable nugget on variables here as well. The HackMonkey knew how to set and unset Drupal variables with Drush, but didn't realize Firebug could dig the variable names out of the rendered page. There is also some great stuff on dealing with databases, monitoring Watchdog and using cron in the second chapter. There is one very minor typo in an example, the command to use cron is "drush cron", not "drushcron". However, since all Drush commands start with drush, a space and then the command, that is a pretty easy one to figure out.

The third chapter dives into the more advanced stuff, like writing our own commands, executing PHP from the command line, and optimizing the terminal with the core-cli command.  To make the most of these tools, some knowledge of PHP, SQL, and the Drupal API will be required. Site aliases and Drush config files are also covered, and are powerful tools that any Drush user can leverage. In the beginning of the book the example of syncing a development and production database with the simple command $ drush sql-sync @somewebsite.com @somewebsite.local is shown. Chapter 3 explains how this is done with site aliases.

The last chapter covers how Drush can interact with other modules from the command line, instead of pecking through the GUI. This falls into the category of "which are you more comfortable with?", the CLI or the GUI. There is a nice demo on using Drush to create a boilerplate starting point for building a module, which will save the habitual module builder some time.

The very last topic in the book just happens to be the one thing about Drush that the HackMonkey literally is bananas over - Drush Make! This fantastic tool can literally download Drupal core, all the modules and themes a site needs, apply patches, grab external libraries pull from Git repos and numerous other things with something as simple as $ drush make mysite.make mysite.com. Drush Make is awesome, read this section! The book doesn't cover all the different things that Drush Make can do, but the readme file included with Drush Make does. Drush Make is such an incredible time saver, it takes less than a minute for Drush Make to pull all the code together for hackmonkey.com!

Conclusion

Drush is awesome, and should be in every Drupal site builders tool box. The Drush User's Guide is a great resource for those just getting started with Drush, or for those looking to take their Drupal mastery to the next level of efficiency. At the start of the book, it is mentioned that commands would be shown full length, instead of the shorter command aliases. Anyone that uses Drush for any amount of time, wll quickly want to adopt the aliases. For example cache-clear becomes cc, watchdog-show aliases to ws and pm-download shortens to dl. While a cheat sheet of Aliases might have been a nice inclusion as an appendix, the good news is that all the aliases and extended syntax for all of Drush's commands are nicely documented on the Drush website, drush.org.

Disclaimer

The copy of Drush User's Guide that was used for this review was provided at no charge to Scott Wilkinson of HaloFX Media LLC by Packt Publishing. However, no other compensation was received for this review and this review was published without prior review or any influence from Packt Publishing.

May 15 2012
May 15

Most Drupal books tend to be very code oriented, or spend the first 25% rehashing the same basics from a dozen other books. If you haven't installed Drupal, forget a book and get cracking over at drupal.org! If you are having trouble installing Drupal, odds are a book will not have the magic answer. More direct help may me needed. Luckily this book jumps right in to the content and doesn't waste any time!

At 170 pages it is a quick read, and a cheap read as well. Drupal Association Members can get the ebook for about $7, directly from O'Reilly! (Which is what the HackMonkey did.) You are a member of the Drupal Association, right? Design and Prototyping for Drupal is actually the second book in a 3 book series, which also includes Planning and Managing Drupal Projects and Drupal Development Tricks for Designers. All three are soon to be bundled together as a single book targeted at designers. Don't let that fool you, this isn't all pretty pixels and unicorns. This book is about getting work done, and the expectations are very much inline with HackMonkey's, the reader is expected to know HTML & CSS, but not be fluent in developer speak.

The primary topics relate to:

  • Sketching and wireframing
  • Breaking down a layout for Drupal
  • A brief discussion on grids
  • Some theme basics, including base themes and sub themes
  • Dealing with generated markup, focused on Views
  • An introduction to LessCSS

That is a fair bit of info to cram in, but Dani does a pretty good job by not languishing on any particular item, much. She keeps it brief, and meaningful.

Alright, one minor correction (already?!) Installing Drupal is touched on, but done so in a brilliant way! (Take note, anyone preparing to write a Drupal book!) Dani takes one paragraph, not a chapter, and simply directs readers to NodeOne's amazing Learning Drupal 7 screencast series. Bravo!

The books 15 chapters are grouped into 3 parts:

Part I
Getting Started: Some Stuff to Consider

Immediately no punches are pulled as she quotes Dries Buytart stating he makes designers write PHP, which is of course horrible code. The point is made that Designers using Drupal may occasionally have to peak under the hood to better understand what Drupal is up to. This is really about understanding and learning, not producing the next big module. The chapter continues on explaining the importance of focusing on the content, structure and functionality of the site; reserving the visuals till later. She breaks down the design process into 4 steps: 1) Ideation, 2) Wireframing, 3) Design Comps, 4) Iteration and Client Signoff. It is obvious she shares the Monkey's view that design is problem solving, not just images. This section is wrapped up with a quick run down on a few software tools for the Drupal Designers Toolkit.

Part 2
Design and Layout

Straight into Ideation and sketching. Included is a conversation with Mike Rhode and some examples of his process.

Included is one of the better break downs on using and creating Style Tiles I have seen, without droning on about each little part. While mobile isn't a topic in this book, the Monkey would note that Style Tiles are also an good way to explain visuals to clients for Responsive/Adaptive sites, without having to do a dozen mock ups.

The beginning of layouts are covered, focusing more on elements, such as tabs, H tags, blog titles and alerts. This avoids being blinded details, by focusing on the "page". There is also a new topic to the HackMonkey - Greyboxing.

The almighty grid! We also get the first peak at some HTML and CSS3. Todd Nienkerk discusses his love for grids. Again I learned something new, the CSS3 grid layout module. Pretty cool stuff, and a mind bender- an actual w3c draft,  CSS3 grids are only supported by IE10 at the moment. Duck! That is the sky falling!

A chapter on Fireworks, huh? Actually this chapter was an eye opener. I had long since dismissed Fireworks as "not Photoshop", however this chapter showed Fireworks strength of dealing with vectors and objects to mock up and design to a grid. The HackMonkey will be digging out the DVD to install Fireworks for the first time under Adobe's reign, and re reading this chapter.

Part 3
Prototyping, Theming, and Managing your Markup

There is a quick run through prototyping, including a discussion with David Rondeau. Layouts are broken down into smaller pieces, such as Nodes, Views, and Blocks.

Popular base themes are discussed, with some tips on evaluating them. The awesome Omega theme gets some extra attention, but a couple features mentioned are actually part of the Delta companion module. That is followed by a quick primer on creating a child theme. Jason Pamental discusses the somewhat controversial topic of theming in the browser.

Then there are 2 chapters of Views tutorials. Rather lengthy Views tutorials at that. They are well done, with lots of screen shots, but it seemed a bit out of place at this point in the book. However...while the first tutorial was a rather typical, it sat the stage a very good tutorial on controlling views markup. Drupal 6's Semantic Views, which are now in the core Views 3 on Drupal 7, are highlighted. There is also  some CSS and a little foreshadowing of LessCSS. The 2 chapters are quite good together, but still felt somewhat out of place, as they are the only areas actual site building is done in the book.

A few modules to help manage code are then highlighted. Personally, this HackMonkey would have rather seen this chapter expanded and the Views chapters shortened. There are many good modules to help wrangle code.

Finally we learn about this LessCSS mentioned and even shown previously. CSS Preprocessors are awesome! The HackMonkey will be giving more love to these in the future. Perhaps it is because the HackMonkey is more inclined to Sass as a preprocessor, but it would have been nice to at least mention Sass/SCSS and Stylus? Sass and Less pretty much work the same, and are wrote the same, except they are processed differently. Less is processed with javascript and Sass is Ruby. While Sass seems to be grabbing a larger share at the moment, none the less, CSS preprocessors are awesome, no mater which flavor you choose. This final chapter is a good, quick overview of the power of preprocessing CSS.

Conclusion

This really is one of the better Drupal books this HackMonkey has read recently. It actually taught me something by just reading it, as well as cause me to rethink my stance on Fireworks. I knocked it out on my flight to Drupalcon Denver. It covers some great areas that don't get much attention in the other avenues, and doesn't heap on a pile of code. You aren't going to master any skills from reading it, but will give you enough info to understand the value of the topics and wet your appetite to dig deeper. Additionally, the editing is done quite well. In the rush to get books out, there have been a few other Drupal titles that have severely suffered from bad editing.

Disclaimer

The copy of Design and Prototyping for Drupal used for this review was purchased privately by Scott Wilkinson of HaloFX Media LLC. No compensation was received for this review and this review was published without prior review or any influence from O'Reilly Media, Inc.

Jan 30 2007
Jan 30

Error message

Deprecated function: The each() function is deprecated. This message will be suppressed on further calls in menu_set_active_trail() (line 2405 of /home1/markspap/public_html/kathy/includes/menu.inc). January 29, 2007

Now that I've worked on a few projects with Drupal v4.7, I have to say that I'm impressed as all get-out with it. Personally, I can't think of any reason not to use it on a majority of projects. But Drupal is my personal preference, and I'm not sure it would be the best one for everyone. Movable Type and WordPress are two of the most popular blogging systems. Although they can be used for other types of sites, they were specifically designed for weblogs. Their functionality and features are limited. But what they do, they do very well. For simple sites or weblogs, MT and WP are fairly quick and easy to set up. On the other hand, Drupal is a powerful publishing platform that can be used for everything from e-commerce sites to portals to intranets. It can also be used for blogging—in fact, multiple user weblogs are a default option. I have to admit that running a one-person blog with Drupal is a bit like going after a gnat with a bazooka. But some people like that kind of firepower. For them, the complexity and difficulty of running Drupal is more than rewarded by its versatility. Indeed, for some Drupaliers, developing the necessary skills is a reward in itself. At present, MT and WP are the "point-and-click instamatics" of weblogging software—Drupal is more for those who have their own darkroom in the basement. And this is unfortunate. Drupal is far superior software, and the lure of cool new features could make developers out of a whole generation of otherwise uninitiated users. In addition, the funding that comes with popularity wouldn't hurt Drupal, either. But Drupal will never be widely used outside the development community until it becomes easy enough to install to appeal to the "point-and-click" crowd. I've heard rumors that more custom distributions like CivicSpace and DrupalED may be coming from Drupal developers. With more preconfigured distributions with very good documentation, Drupal could well give MT and WP a run for their money.

Similar Notes

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