Friday, April 25, 2014

Drupal Job Interview Questions and Answers ( a set of 50 questions, q52-q101)

101. What hardware does run on?

People often wonder what kind of hardware runs on. Throughout the project history this has been a tough question. For a while it was a server in a random office building. That server eventually died and required a fund-raising effort to replace (the funds were raised in 24 hours!).
The critical infrastructure is all configured to share the load and be redundant. For example, db1 and db2 are configured to be master-slave most of the time to provide for better performance and allow the slave to be promoted to master if the master fails.

100. Drupal and Working with JavaScript

Drupal provides methods for implementing JavaScript. Using these methods will help to keep your code clean and to ensure compatibility with the way other modules implement JavaScript.
A couple of simple principles guide Drupal's JavaScript approach:
·     All pages should be perfectly functional without scripts. JavaScript provides alternatives or supplements - not replacements - for standard elements.
       No JavaScript is hard-coded into pages. Rather, actions are attached dynamically to page elements--and only if the needed JavaScript support is present.

99. Why does Drupal need a database? What databases are supported?

Drupal stores its information - the individual pages, the registered users, and so on - in the database. The database forms the back-end for your Drupal site. At this time, Drupal supports MySQL (or an equivalent such as MariaDB), PostgreSQL, and in Drupal 7, SQLite.

98. How to create a static archive of a Drupal website

97. Programming best practices and CMS(drupal) best practices

Programming best practices


Best practices (drupal)

96. what are Drupal Distributions and Drupal installation profiles and what is the difference between the two

·         Installation profiles are what a developer creates as the basis of distributions. They define installation steps (such as enabling modules, defining content types, etc.) that run after Drupal's base installation when you first install Drupal. One or more standard installation profiles are included in the Drupal Core download; developers can create custom profiles that set up Drupal for specific purposes, and optionally release them for community use on It is not always easy to attempt to use an installation profile directly, if it requires non-core modules, themes, or libraries -- you would have to locate and download all the required components yourself before you could install Drupal. Instead, it's a lot easier to download a full distribution (if available).

·         Distributions are full copies of Drupal that include Drupal Core, along with additional software such as themes, modules, libraries, and installation profiles. The automatic packaging scripts on turn installation profiles into distributions, by gathering all the modules, themes, and libraries they require into a single zip archive, so that all you need to do is download the full archive and run the install script.

When to use distributions

There are no hard and fast rules about when to use distributions, but here are a few guidelines:
·         Evaluating Drupal: If you're just getting started with Drupal it makes sense to try a distribution, since they are easier to setup and you can see real life examples of what Drupal can do. Not all distributions are equal though, so start with a popular well maintained distribution.
·         Demoing Drupal: Before building a site for someone it can be useful to show them examples of how Drupal can be configured.
·         Learning Drupal: In the administration section of a distribution, you can study the inner workings of a real example of Drupal site, learn all the details about how it is built and configured to obtain specific functionality, experiment with any changes and additional modules and themes, etc.
·         Quickly building a site: If you're building a site similar to one provided by a distribution it makes sense to start with a distribution. After installing you can continue to configure the site, add modules, create themes, etc. You can even undo things that the installation profile script may have done. If you're changing too much though it may make more sense to just start with stock Drupal and build from there, rather than try to undo and change what was setup for you.

Read Full article here

95. Drupal coding standards

94. Drupal 8 classes and interfaces

93. Explain drupal advanced search

When Drupal does a search, and returns no results, an advanced search form is displayed. The form contains a list of content types and below fields.
1. Containing any of the words
2. Containing the phrase
3. Containing none of the words 
And users can choose the search criteria if they are not able to find what they want from basic search.

Wednesday, April 23, 2014

92. Drupal 8 , Changelog.txt - What's new in Drupal 8

Drupal 8.0, xxxx-xx-xx (development version)
- Added Twig as the default template engine and converted all .tpl.php templates
  to .html.twig.
- Added tour module. Provides highly contextual tips for UI elements.
- Improved entity system.
    * Added support for saving and deleting entities through the controller.
    * Entities are now classed objects, implementing EntityInterface.
    * Drupal now understands the concept of a "default" revision, tracked
      independently from the latest revision, allowing for the creation of
      drafts while the current revision stays published.
    * All entity types, not just nodes, now have support for revisions.
- Replaced the core routing system with one built on the Symfony2 framework.
- Configuration:
    * Added a centralized file-based configuration system.
    * Allows module authors to provide configuration in a standard format.
    * Implements functionality to get, set, add and remove configuration.
    * Includes ability to override configuration values with language variants
      and other runtime values.
- Added the CKEditor WYSIWYG editor. Provides a drag-and-drop configuration UI.
- Included the HTML5 Shiv library to support HTML5 elements in IE 8 and below.
- Included the following Symfony2 components:
    * ClassLoader - PSR-0-compatible autoload routines.
    * DependencyInjection - Flexible dependency injection container.
    * EventDispatcher - Object-oriented lightweight event handling system.
    * HttpFoundation - Abstraction objects for HTTP requests and responses.
    * HttpKernel - Core system for managing incoming HTTP request and responses.
    * Process - Allows for executing commands in a sub-process.
    * Routing - Framework for mapping incoming requests to controller
    * Yaml - Parser for YAML files.
- Included the Assetic asset management framework for PHP.
- Included Backbone.js and Underscore.js JavaScript frameworks.
- Support added for making HTTP requests through a proxy server.
- Removed modules from core.
    * The following modules have been removed from core, because contributed
      modules with similar functionality are available:
      * Blog
      * Dashboard
      * OpenID
      * PHP Filter
      * Poll
      * Profile
      * Trigger
- Removed the Overlay module from core.
- Removed the Garland theme from core.
- Removed the Statistics module's accesslog functionality and reports from core.
- Removed backwards-compatibility with 'magic_quotes_gpc'/'magic_quotes_runtime'
  PHP configuration settings. Both are required to be disabled.
- Universally Unique IDentifier (UUID):
    * Support for generating and validating UUIDs.
- JavaScript changes:
    * Updated to jQuery 2.1.0
    * Updated to jQuery UI 1.10.2
    * Removed jquery.bbq
- Tremendously improved language support all around.
    * Great language improvements for users:
      * Improved language selection with user preference detection in the
      * Moved base language support to Language module.
      * Greatly simplified the interface for setting up languages.
      * Improved browser language detection considerably.
      * Language domain and path prefix configuraton simplified and centralized;
        path prefix detection is now default.
      * Added HTML 5 language markup; language information added in markup in
        several more places.
      * Made it possible to assign external language codes to local languages.
      * Introduced the possibility of an administration-specific language
        preference for users.
    * Simplified and added new features in interface translation:
      * Made interface translation directly accessible from language list.
      * Centralized interface translation import to one directory.
      * Drupal can now be translated to English and English can be deleted.
      * Much improved built-in translation interface.
      * Added support for singular/plural discovery and translation.
      * Customized translations are tracked so your modifications can
        be identified and protected from translation update overwrites.
      * All Gettext files are now imported in chunks, better for low resource
    * Improved content language support:
      * Made it possible to assign language to taxonomy terms, vocabularies,
        menu items, and files.
      * Added a field translation based content translation module that applies
        to all content entities.
      * Removed the old node-copy based content translation module.
      * Introduced language defaults configuration for each entity type and
      * Added entity language variance support to search module.
      * Search indexing and query preprocessors now get language information.
      * Unified content translation permission granularity with content editing
      * Made the language selector freely orderable in entity forms.
    * Better configuration language support
      * Added language selectors to most configuration options (views, menus,
      * Added a configuration translation user interface that works with any
        configuration with translatable values (blocks, views, fields, etc).
      * Added language options to block visibility.
    * Much improved language APIs for developers:
      * Added simple APIs and hooks to save/delete/update languages.
      * New Language class wraps language information, used universally.
      * Unified database schemas and APIs to make it easier to spot where
        language codes are referenced.
      * Made the language negotiation system APIs more consistent for
      * Made it possible for users to have a preferred language separate from
        their user entity language.
      * The text formatter from t() is now available as format_string().
      * Added support for interface translation contexts in Drupal.t(),
        Drupal.formatPlural() as well as routing, tabs, actions, and contextual
      * Removed textgroups support from interface translation in favor of
        native configuration language support.
      * Added configuration schema system to support generating translation
        forms for any configuration.
      * Reworked Gettext PO support to use pluggable read/write handlers.
      * Added language select form element in the Form API.
- Added E-mail field type to core.
- Added Link field type to core.
- Added Phone number field type to core.
- Added local image input filter, to enable secure image posting.
- Added Views and Views UI module to core.
- Added Entity Reference field type to core.
- Added Date field type to core.
- Added a Web Services module package.
    * Added a RESTful web services provider module.
    * Added a serialization module using the Symfony serialization component.
    * Added a Hypertext Application Language (HAL) serialization module.
    * Added a HTTP Basic authentication provider module.

91. Drupal Negatives and explanation on Usability, Learning curve, Backward compatibility (for software development), Performance, scalability, Integrability with hosting structures and Search

·         Usability
      Aspects of the Drupal 6 administration interface were seen to be confusing and intimidating to some, particularly for new administrators. According to Dries Buytaert, Drupal 7 addressed 90% of the problems identified by Usability tests conducted at the Universities of Minnesota and Baltimore. To achieve this, Acquia(the company founded by the project lead of Drupal) hired user experience designer Mark Boulton to work with the Drupal community to design an improved user interface for Drupal's administration interface. The majority of his team's design work has been implemented by the community in Drupal 7. The 2011 usability test results from the University of Minnesota Office of Information Technology show that all of the major usability problems identified in Drupal 6 are either vastly improved or non-existent in Drupal 7. However, some new usability problems were identified. Since the release of Drupal 7 there are now various distributions and applications to enhance the Back-end Usability of Drupal such as Drupal Gardens, Open Enterprise  and Mitkom Builder.

·         Learning curve
         Some users describe Drupal as being difficult to master. Drupal's many contributed modules can have overlapping functionality and have been reported as overwhelming to new users.

·         Backward compatibility (for software development)
      Drupal does not commit to backward compatibility across major revisions. This means that module and theme developers may have to rework their code to be compatible. However, Drupal's policy is to not change how it uses one's data. This means that data from previous versions will still be usable without alteration in the new release. Drupal documents any incompatibilities, allowing the user to make informed decisions about when and whether to upgrade.

·         Performance/scalability
       In 2008, performance tests between Drupal 6.1 and Joomla 1.5 demonstrated that Drupal's pages were delivered "significantly faster" than those of Joomla. Despite this, arguments over speed persist. Drupal is likely to be slower than a special-purpose application for a given task. For example, WordPress typically outperforms Drupal as a single-user blogging tool. Drupal positions itself for broader applications requirements that are outside the scope of more narrowly focused applications. Drupal offers caching to store various page elements, the use of which resulted in a 508% improvement in one benchmark. When using Drupal's default Page Cache mechanism, the cached pages are delivered only to anonymous users, so contributed modules must be installed to allow caching content for logged in users. Like performance, scalability (the ability to add servers to handle growing numbers of visitors with consistent response) can become a concern on large, interactive sites. MySQL's query caching can help reduce the load on the database server caused by Drupal's high query rate. Drupal caches database schema metadata as well as elements such as blocks, forms and menus. Drupal 7 increases performance in database queries and reduces PHP code usage.

·       Integrability with hosting structures
       Because of Drupal's demanding query requirements, Drupal-based websites can quickly become very taxing to hosts whose databases reside on a machine separate from their HTTP server. While the issue can normally be addressed by implementing aggressive caching as described above, such methods may be unimplementable in cases where the host does not offer access to PHP accelerators like XCache or APC. Drupal has plugins that facilitate similar caching without requiring special PHP extensions.

·         The Drupal core search 

 There are contributed modules that will greatly improve the search functionality on a Drupal website, but they are not easily accessible due to a high learning curve and the difficulty users have in general of finding the right module. One of the faceted search options is Apache Solr Search Integration module, however, the module requires a dedicated server or virtual private server (VPS) to operate because Solr must run on a servlet container, e.g. Tomcat, Jetty or Resin. These requirements make it harder for a Drupal website to have a functional search feature. In response, Acquia and other companies have created Apache Solr SaaS products.

90. Explain Drupal Architecture

Drupal is based on less publicized but still widely used architecture Presentation Abstraction Control, or PAC. The menu system acts as the Controller. It accepts input via a single source (HTTP GET and POST), routes requests to the appropriate helper functions, pulls data out of the Abstraction (nodes and, from Drupal 5 onwards, forms), and then pushes it through a filter to get a Presentation of it (the theme system). It even has multiple, parallel PAC agents in the form of blocks that push data out to a common canvas (page.tpl.php).

89. Drupal Version release dates

Release dates

1.0      15 Jan 2001

2.0       15 Mar 2001

3.0        15 Sep 2001

4.0       16 Jun 2002

4.5        16 Oct 2004

4.6       16 Apr 2005

4.7       16 May 2006

5.0      15 Jan 2007 

6.0      13 Feb 2008

7.0      5 Jan 2011

7.26    15 Jan 2014

8.0 Drupal 8 is in development, with no set release date yet. The work on Drupal 8 is divided into categories, called Core initiatives: Mobile, Layouts, Web Services, Configuration Management, and HTML5.

88. Drupal at a glance


Initial release
January 2001
7.27 / 16 April 2014
Development status
Written in
11.4 MB (uncompressed core)
Available in
GPLv2 or later