Drupal Planet

Subscribe to canal de noticias Drupal Planet
Drupal.org - aggregated feeds in category Planet Drupal
Actualizado: hace 37 mins 3 segs

OpenSense Labs: The Guide for Maintaining & Building your Drupal Website

Vie, 01/25/2019 - 09:11
The Guide for Maintaining & Building your Drupal Website Vasundhra Fri, 01/25/2019 - 16:41

When I say that a mere thank you to the development of site building tools won’t be enough, would you agree with me?

You might, you might not. 

But imagine a building that is under construction. Without the use of the right raw materials and tools (like cement, bricks, metal rods, labor etc) the task of constructing and maintaining it would be difficult to achieve. 

Right?


In the case of Drupal website, modules play a similar role, like that of the site building tools. 

We can witness a myriad of modules to build and maintain a Drupal website. These modules build a foundation to the website structure that continually adds the "bricks" to make a sound and holistic site.

But, the main question is - Which modules are the right one to build and maintain a website? 

Site Building vs Frontend vs Backend   Site Building Frontend Backend Refers to the Supporting of all the digital marketing efforts.   The client side of the application   The server side of the application  Constitutes of Web design and development for the site building process. The part which the user can see and interact with Everything that happens behind the scene  It covers Site hosting, Themes, multi-domain, HTML, CSS etc  The visual aspect of the website. The server requests. The web server communicates with the database. Serves in Helping an effective communication with the audience.  Creating user-friendly pages. Maintaining application and database. Things you would need to build a website 

When you are constructing a Drupal website, there are a lot of things which are needed. As important as it is to write your HTML and CSS codes, several other factors contribute highly to the whole process. Factors like:


Web hosting service 

When you upload your files on the cloud, only those people are able to access them whom you have granted the authority to. 

Well, think of web hosting as the same. Your website is the file and is essentially being put on the internet for the people to be viewed. Instead of sending complex website files to every person you can simply provide with your website URL and they can easily view it all. 
Web Hosting allows you to put all your website content for people to view them. Instead of sending those files to people, it allows you to host them online. Having web hosting means that all your potential readers will be able to view your content at anywhere at any time.

While choosing a hosting service, you must consider 4 big factors:

  • Uptime: Uptime percentage shows how much time your site will be up and running. Note that weak server and unstable network connections can often push your site offline. Banking on a hosting company with reputable uptime score, preferably above 99.5% is the key to your site success. 
     
  • Page load speed: You should choose a host that loads faster than 850 ms, which is the current average. Factors like a fast hard drive, locating essential resources easily, dedicated and enhanced resources contribute highly to the page load speed. 
     
  • Customer support: This is an important aspect for your web hosting. Your provider should have a good, responsive, solid reputation in their support department. Most of the providers offer multiple levels of support like emails, toll-free phone, live chat and much more. 
     
  • Price: Everyone wants a web host that is affordable and reliable.  In short, choose the one that you can manage. Make sure that the web hosting organization which you chose has an in-house support department. Compare all the features with each provider in your list and then make a decision. 

Modules 

Drupal is like a blessing to its users. It has a loyal, supportive community that contribute highly to the whole section of modules. It provides its users with excellent modules to the system. All these modules are the set of PHP, CSS and javascript files that present with unique features and functionalities. 

Different Drupal modules would add different functionalities to the website

Drupal 8 core provides modules for functionalities such as.

Functionalities  Modules  Managing User Accounts  Core User Module Managing Basic Content Core Node Module Managing Fields  Core Fields, Field UI modules, Core Modules providing Field Types  Managing Navigation Menus  Core Menu UI  Making Lists, grids, and blocks from the existing content  Core Views, Views UI Module 

Time Savers 

Timesaver is a turnkey timesheet management application designed for businesses of all sizes. The simple and intuitive design lets your administrator set up the system quickly and lets employees use the system with minimal training. The configurable timesheet entry periods would allow you to tie in the pay hours to the timesheet system. It not only provides an easy to use manager workflow that accesses, approves, edits and lock the employee's time but also allows the administrator to configure the task of customers, projects, activities with ease. Some of the amazing features that are granted by time savers are:

  • It provides the users with easy to use interface. A robust, yet easy interface allows the users to easily began the timesaver system.
  • Starting from the entries to the approvals and ending from rejections to locks, the timesheet system is configurable to suit your needs and requirements.
  • Keeps the sensitive information private and secure. It only allows employees and their delegates or supervisors to view entries. 
  • There are pre-built excel reports that allow customization easily.
  • It easily creates new customers, projects, activities, and tasks.
  • Granting the users with AJAX enabled output that helps in streamlined timesheet entry, reporting, and approvals. 

Environment 

As you read it, from functionality to appearance to navigation and code integrity, a lot goes into creating a good website. In other words, the environment that is around the project plays an essential role in the construction of a website. A good environment would not only result in excellent conversions, but it would also bring out the best end result. It totally depends on the factors which involve:

  • Size of the project: It is an important factor in terms of planning and devising. This is particularly important in a multi-project environment where simultaneous project competes for funds and human resources. Small project methodologies would never fit in the one which has a larger preceptive. Thus, making the size an important factor. 
     
  • Size of the company: Building an adequate empire of your organization plays a vital role when it comes to the environment. The size of the company not only contributes to the growth of a company but also helps to gauge the health of the culture around. Size of the company is underpinned with many other characteristics like discipline, development, management, experience etc.
     
  • Level of skills and knowledge of the team: The importance of quality team members and skilled colleagues matter a lot when it comes to the environment. High-grade and skilled team members mean efficiency and management. This not only boosts the other people around but also helps in completing the goal on time.
Things you would need to maintain a website 

Now that you have created a Drupal website and owned it, there are responsibilities which would rise with it. Maintaining on regular basis is one of them. 

Everyone wants that their website should run smoothly with heavy traffic and incredible conversion rates. 

Using a proper website maintenance program can help you achieve it all. Here are some of the things which you can use to maintain it.

Status report screen 

Drupal provides a feature called Status Report which checks a variety of important issues regarding your site's health, including permissions of the folders that Drupal needs to access. Modules that aren’t working because of other modules or libraries that are not installed will also be printed here. This type of report is even important when debugging issues or technical support issue arises. The report is provided in simple plain text format to minimize problems which arise in cutting and pasting up of files.

Cron 

The term Cron refers to the automated task that a website runs on every “N” hour. Cron should definitely be run on your Drupal site in order to keep it healthy. It helps with scheduled tasks like clearing the cache, running jobs like e-mails, reminders etc that can be configured automatically to execute tasks without any manual involvement. 

A properly configured Cron job manages a variety of task.

  • It helps in updating the index of the site content which is used by the search module.
  • Queues feeds are updated with the help of the Aggregator Module.
  • It checks the available updates for the Update Manager module 

It performs routine maintenance task for the System Module.  

Caching 

Caching is the strategy that improves the efficiency of accessing existing information types. Any information which is in the raw state can be cached into its non-raw state. During the processing of HTTP requests, the information from a different source can be stored in different bins. These cache bins then each is stored in different configurable backends. 

By default Drupal enables two modules for caching:

  • The Internal Page Cache Module: This module caches pages for anonymous users in the database. Pages that are requested by anonymous users are stored the first time they are requested and then they are reused for future visitors. 
     
  • The Internal Dynamic Page Cache Module: This module aims to speed up the site for both anonymous and logged in users. 

Deployment 

Drupal deployment is designed to allow the users to easily stage content from one Drupal site to another. In other words, when you are working on a Drupal site it is a good practice to use one or more different environments to develop or test your website without affecting the live site’s availability to the world. The changes which are made in the code or the configuration which of the developed website are then deployed with the help of the automated process. This helps you to create various content types or modify the configuration of the front page. You can then deploy those changes without resorting the replicated changes on the live website. 

How can Drupal help in Building your Websites? 

Drupal 8 is a great system to use, instead of trying to code or pay the third party to build the website, Drupal tends to deliver all the elements for an online presence. 

Like good buildings, Drupal website can be very solid, beautifully designed and convenient in every way. After you have installed Drupal and selected a suitable web host, it’s time to start building the website. 

Drupal 8 comes with the most popular text editor module as well as image uploaders which provides you with basic HTML control and tools when writing content. Text editor modules like paragraphs give you cleaner data structures so you can give more editing power to your end-users, and if you are worried about your mistakes - Environmental Indicator would help you with the correction of all your errors. It would create multiple environments which would make navigation easy. 

The CMS also provides site builders and administrators with a powerful user interface to create custom automated workflows on a website, without any coding, using "reactive" rules. Site builders can use the rules module to react when something happens on a site and conditionally manipulate data or execute any logic necessary. 

Once you have created the data on your website would need elements to arrange it. Panelizer module would allow you to arrange the fields in your content such that no fields are stacked on top of each other. In short, it would allow you to attach panels to any type of node in the system and customize your content.

Copying files folder to the development and downloads the files from a specified server have been easy with the help of stage file proxy. It is a general solution for getting production files on a development server on demand. With the help of backup and migrate module you can dump some or all of your database tables to a file download or save to a file on the server or offsite. Therefore, all your current data in your database related to the users can be masked with the help of Mask User Data (GDPR)
 
There is a devel module in Drupal 8 that is a valuable tool for constructing and coding websites. Devel is usually used for low-level development of a site. This module also features Drush integration and provides with several custom Drush demands. ( Drush is a shell interface with is helpful in managing Drupal right from the cloud server command line)

Once you are done with the production of your website profiling your site is extremely useful not only for debugging and performance testing but also for learning that how a site handles a request. WebProfiler helps in doing such a task. Its bundle is a comes with Drupal module that for Symfony which helps in collecting the information about each request that is made to your application and allows you to visualize it on the browser. 

How can Drupal help in Maintaining your Websites? 

Now that your website is up and running, you would need to maintain it now and keep an eye on every aspect. This includes appearance, performance and other aspects as well. Fortunately drupal comes with a set of contributed themes. These themes help in the appearance of the site. It allows you to change your look and feel of the website. The PHP template engine has been replaced with the all-new twig template. All themes files are the HTML.twig. It also had made modification in the syntax, .info files become .info.yml files that use the YAML syntax.
 
Drupal is also known for offering excellent multilingual capabilities, ensuring that your website is accessible to the widest possible audience. Modules like local (integrated with the core), content translation (integrated with the core), internationalization, variable contributes to the multilingual aspect of the website.

And if you are thinking that Drupal can't get better than this then think again.  It also comes with multi-domain capabilities. Multi-domain allows you to span one site across multiple domains. You can configure which domains to use for different parts of your site including which protocol that section uses.

Drupal is for everyone. From developers to marketers, it has extended its horizons. The instantly installable and no programming requiring modules come with customizable shopping carts and products which are showcased pertaining to a theme. With it, one can create taxes, discounts and charges heads and even give opportunities for subscriptions and recurring payments. Make the top e-commerce modules to receive donations too.

Wrapping up

Depending upon the requirements and keeping in mind both the security and scalability of the website, Drupal is and has always been a very powerful and flexible platform. True, that it presents us with secure and reliable modules and keeping in mind certain features and factors - Drupal has won many hearts. 

Hence, to have the best website experience you need the best organization. Opensense Labs has been harboring strong relations with its partners and providing them with ample solutions and digital services

Contact us at hello@opensenselabs.com to get the best digital experience.

blog banner blog image Drupal Drupal 8 CMS Website Maintenance Website Building Drupal Modules Support and maintenance Blog Type Articles Is it a good read ? On

OpenSense Labs: Can I Boost the Performance of My Team Members?

Vie, 01/25/2019 - 09:04
Can I Boost the Performance of My Team Members? Vasundhra Wed, 12/25/2019 - 15:56

Suppose you wish to create a thriving vegetable patch. 

What would be your starting steps?

You would read the instructions, plant seeds and provide them with a proper environment (sunlight, water, time).

Correct?

You wouldn’t just throw seeds around and order them to grow - “Hey you, become a cabbage right now”


Same is the case with a team. Nurturing a healthy team culture is really important for the growth and development of an organization. When your team is “in the zone”, being productive and on time, you acknowledge that phenomenal feeling. 

It’s like a sweet cocktail of emotions -  excited, challenging, safe and successful. Pumped up for the entire day and energized to do the work. Happy team members tend to achieve the desired goals at a faster pace than the ones which are not looked upon. 

And this is how you can achieve it.

Personal Development Plan

The first step to help the team members achieve their personal goals while contributing to the company’s goals is implementing the Personal Development Plan.

Personal Development Plan shows the team members all the opportunities in the company and helps them to set a clear but ambitious goal for the future. The process of achieving this goal in a transparent corporate culture is motivational.

A Personal Development Plan helps you to think about your future in detail and helps you in getting there with the specifics. 

The process of building your plan can take a considerable amount of time but it is an excellent idea to increase the efficiency and performance of the company. The process includes some important factors which are: 

Clearing your vision

To start with the Personal Development Plan you have to study beyond the end. Think about your future life and how it can be in the time span you choose for yourself, and now take a step back and review yourself. 

What are the areas that would make you feel successful? Or how can you determine your efficiency and values?

Now map them by putting everything you would want. After you have the primary key fields for your development, you would have a clear vision of the areas you have to focus on. 

Areas of improvements

Now that you know what you want, you next have to figure out that what are the means of going towards your goals. Prepare a list of skills you need to develop and the projects which you can start working on. Write down your areas of weakness and strength. This would help you to think about the regions which need improvements and the areas which should be lightly focused on.

Establishing goals 

Now that you have a crystal clear direction let’s get down to the details. The primary agenda is to get down to specific actions for the future. Start by setting up particular projects and the resources which would be needed to complete those projects. 

This would give you an idea about the things that are needed to be done and the ways in which it is supposed to be completed. You can even tie up your personal development plans to the annual goals. 

Reviewing and Adapting  

To make sure that your goals are being achieved, it's important to review them. Reread your vision, check out the values mind map and then focus on what needs to be done. If you feel that some projects no longer make sense to you, don’t hesitate to remove them from your plan. Also, don’t hesitate to adapt to the plan which has been added with new interests and outcomes. Your personal strategy would grow the way you do.

Feedback Survey 

Happy employees are more productive than the ones who are just sloping around at the workplace. And how can you make an employee happy? 
Definitely, by asking them about their needs, because let’s face it, it is difficult to predict the wants and requirements of your employees as you aren't a psychic.

So how would you do it?

By conducting feedback surveys. 

Feedback Survey helps the employers to receive meaningful and constructive feedbacks which are crucial for the growth of an organization. It creates a positive working environment which not only delivers happiness to the team but grants them with an added level of satisfaction.  

Feedback encompasses many aspects like work and team performance, Skills, and competencies, an employee’s well being, strategies etc 

It is all about helping employees and organization with personal effectiveness and excellence by creating opportunities for the employees and boosting the company with satisfactory culture environment. 
 

Questionnaires 

So now that you know how much feedbacks are important for the growth, it is important to know that what all questions should be put in front of the employees to get the best result. 

Employees don’t like the proverbial my-way-or-the-highway boss, control freak, or the micromanager. So how do you avoid being a bad leader to your team? 

It’s all about the right questions.

The real questions can dramatically improve an employee’s morale, output, and quality of work. Asking the questions is perhaps the only way to be a truly effective work manager. The following list of questions can effectively build and boost team performance. 

Personal and Company related Questionnaires 

There is no doubt to the fact that each one of us has a value system, which holds our everyday decisions. Also, the organizations that we work in, base their daily activities on a certain value system that they use. However, questions of how much do our personal values coincide with the prevailing/existing values of that of an organization can provide you with adequate research. Questions like:

  • What’s your biggest accomplishment this month?
  • What should we do differently?
  • Is there anything that the company can help you with?
  • What process can be fixed or improved?
  • What inspires you to succeed every day?

Self-assessment

A focused employee is a reliable employee and what can be the best way to review your work than self-evaluation. Self-assessment allows for management and their workforce to engage in a helpful dialogue about career development and goals. Some of the questions which can be put for self-assessment are:

  • What’s your biggest challenge right now?
  • What resources would be helpful to you right now?
  • Anything in your work world that’s less than stellar/causing frustration or delays?
  • Looking back to the week is there anything that could have been done better?

Future Goals

Growth creates opportunities for your people to develop their skill, attract the best talent for your company, and create wealth for you and your investors. Therefore, to achieve that growth it is important to have new ideas and notions for the future. To know that you can put up questions which include:

  • What are the things that your work environment should have to improve the performance of the organization?
  • What additional training or education can the organization provide to bring out better results?
  • Where do you see the company in 10 years?
Presenting results and structuring the follow-up talks 

There are good meetings and then there are bad meetings. Bad meetings drone on forever, you seem to never get an idea about the accomplishments and the goals. Whereas good meeting leaves you with solid plans and structure on how to achieve them. Thus, if you structure your meeting plans, preparation, execution, and follow-ups around these following factors then an effective result can be witnessed for your organization.

Achieving the meeting’s objective 

An effective meeting serves a useful purpose. This indicates that in after conquering those objectives you would tend to get the desired results. With the end result clearly defined you can plan the content of the meetings, and determine the people who should be present.

Minimum time and more productivity 

Time is a precious resource and no one wants that their time should be wasted. With the amount of time that we spend in a meeting, you tend to owe it to yourself and the members which are there in the meeting to have a clearer vision on what has to be achieved and that what all is possible. The time that is wasted in a meeting is time wasted for everyone which means less efficiency and less productivity. Assigning particular topic of discussion to various people is a great way to have qualitative progress. 

Structured Process 

Now that you have the agenda prepared, you need it to circulate among the participant and get their feedback and inputs. If there is something that a team member needs to add then a lot them with the task. After the meeting is over take some time to debrief and determine that what went well and the areas which need improvement. Evaluate the meeting effectiveness based on how well you met the objectives. 

Conducting Basic Coaching Conversations 

You can help your reporting employees improve their current performance, or in case of already effective ones, you can boost them to another level of effectiveness by having basic coaching conversations. Performance is a powerful tool when it comes to coaching team members. 

Note that the goal of performance coaching is not to make the employee’s disheartened, nor it is to help to provide a show on how much the HR professionals or manager know. The main goal of coaching is to work with employee’s to solve performance problems and is done to improve the work of the employee’s. 

Thus by using these following steps, you can provide effective support to your reporting employees. 

  • Show confidence in the willingness and ability of employees.
  • Describe and explain the performance problem and behavior of the employee.
  • Determine how to remove the four common barriers: time, training, tools and temperament.
  • Discuss the potential solutions.
  • Agree on a written action plan that includes the employee, the manager, and the HR. 
  • Set a date and time for the follow-up.
Possible challenges that can be faced 

Advancing and using effective employees performance is quite difficult and challenging. This is especially true if your company uses a workgroup or team structure and you want to assess the quality of the team's performance. The challenges can vary from employee’s belief to trivial coordinating issues. There can be a number of challenges that can be encountered among which some are:

Low interest in filling out surveys 

Everyone wants a 100 percent response rate for the betterment of their organization. The level of participation in filling out survey forms can be either extraordinary or not at all. Two main reasons where an employee might not participate could be because:

  • Many employees through several surveys and no change seems to come to the results.
  • Fear of being judged or misinterpreted. 

Poor feedback or no feedback

National Business Research Institute shows the importance of the annual employee survey. It explains that employee engagement increases the overall profit margin up to 6% and results in five times more shareholder return. 

Clearly, most businesses and professionals appreciate the importance of surveys. Poor feedbacks results in misguidance and lowers the growth of an organization. 

Postponed results

Delay in the results exchanges a negative impact on a company. You should not forget that in a project everything and everyone is related to each one that is present under one roof. It is like a chain which is iterative and should be agile. One step missed, the whole goal suffers. Postponed results may occur because of reasons like

  • Inadequate estimations (budgets, timeframes, human resources)
  • Task complexity
  • Unexpected events
  • Organizational strategy prioritizing some projects over other due to strategic objectives.
  • Bad coordination among team members 
Wrapping up 

When you involve appropriate team members in the resource allocation process, you create a spirit of collaboration on important decisions. Plus, you tend to get more accurate results and outcomes. 

If you are looking for a better way to improve performance across your organization, Opensense Labs services are there for you.  Contact us on hello@opensenselabs.com and help your business grow and flourish more. 

blog banner blog image Drupal Drupal 8 CMS Performance Personal Development Plan Feedback Survey Questionnaires Coaching Team Members Blog Type Articles Is it a good read ? On

Tandem's Drupal Blog: Lando + Contenta CMS + Nuxt Pt. 1

Jue, 01/24/2019 - 22:00
January 25, 2019 Set up a headless Drupal architecture in Lando Why? Headless architectures offer many advantages to app construction. From the COPE (create once publish everywhere) strategy, to parallell development of the frontend and the backend of the app, but getting the infrastructure right can be a bit tricky. Let's take a look at ho...

Drupal Association blog: A Step in a New Direction. Farewell from Amanda Gonser.

Jue, 01/24/2019 - 16:49

When I joined the Drupal Association over 4 years ago, I didn’t ‘do Drupal’ and I didn’t have the faintest idea of what ‘the community’ was. These were things I read about in the job description for DrupalCon Coordinator, but didn’t mean anything to me yet. Now, as I prepare to leave Drupal - the Association, the community, the Con, the project - I can actually ‘do Drupal’ (albeit it on a Drupal 7 site, tsk tsk I know) and have such respect and care for the people that I have been lucky to work with from the community.

The journey from Point A to Point B, has been just that - a journey, with many steps in between.

My first DrupalCon was DrupalCon Los Angeles 2015 and it was full of firsts: the first time I met the Track Team who I had seen on the planning calls for months and who were surprised how short I was ‘in real life’; the first time I walked farther than a marathon in one single building; the first time I waltzed to the front of a session room to introduce myself to one of the many volunteer speakers to thank them for contributing; the first time I gained the understanding of how big, how passionate, how special this community was and how important DrupalCon was to all of them.

Since that Con, I have done my best to serve the community that makes Drupal so successful and special. There have been many volunteers, multiple Cons, too many emails to count, and a lot of smiles. As I prepare to step down from my role at the Drupal Association, there are many moments/projects that I am proud that we achieved together:

  • We’ve gone from not tracking diversity of our speakers at all to having our DrupalCon Seattle 2019 lineup be comprised of 50% speakers from underrepresented groups.
  • We held our first DrupalCon in India to serve an incredibly enthusiastic and growing community in what was one of my most memorable Cons ever.
  • We’ve taken the challenge of creating a sustainable and productive DrupalCon Europe and approached it with new eyes and ideas, to craft a new model that is community-driven and on course to be a great event to serve our European contributors.
  • We’ve continued to open our community to new and different audiences, working to create a welcoming environment along with relevant and compelling content for anyone who Drupal impacts- from the CTO to the content editor and marketer.

There are countless other moments that I also consider special - the hugs, the thank you notes that I’ve received, the inside jokes, the staff retreats, the volunteer dinners - thank you for those. In addition to the magic I have felt within our larger community, I also am grateful to the truly fantastic team at the Drupal Association who works to serve the community every single day; I am grateful to have worked with such talented, driven, and fun teammates.

My last day will be February 1, and between now and then I'll be reaching out to all the volunteers involved in the upcoming event to put you in touch with the great team that will succeed me. I am more than confident that the Association, the community, and the project will continue to grow, change, and prosper. Thank you for letting me be part of that, it has been a true privilege to serve you.

In my time here, I learned that to do well in my job, I needed to do my best for all of you. So even though I won’t see you at DrupalCon Seattle 2019, imagine me whizzing by you at speed-walk pace with a smile, shouting lovingly at you to squeeze in the group picture, or receiving a handwritten card from me thanking you for contributing to the Con.

Dries Buytaert: How to decouple Drupal in 2019

Jue, 01/24/2019 - 14:18

The pace of innovation in content management has been accelerating — driven by both the number of channels that content management systems need to support (web, mobile, social, chat) as well as the need to support JavaScript frameworks in the traditional web channel. As a result, we've seen headless or decoupled architectures emerge.

Decoupled Drupal has seen adoption from all corners of the Drupal community. In response to the trend towards decoupled architectures, I wrote blog posts in 2016 and 2018 for architects and developers about how and when to decouple Drupal. In the time since my last post, the surrounding landscape has evolved, Drupal's web services have only gotten better, and new paradigms such as static site generators and the JAMstack are emerging.

Time to update my recommendations for 2019! As we did a year ago, let's start with the 2019 version of the flowchart in full. (At the end of this post, there is also an accessible version of this flowchart described in words.)

Different ways to decouple Drupal

I want to revisit some of the established ways to decouple Drupal as well as discuss new paradigms that are seeing growing adoption. As I've written previously, the three most common approaches to Drupal architecture from a decoupled standpoint are traditional (or coupled), progressively decoupled, and fully decoupled. The different flavors of decoupling Drupal exist due to varying preferences and requirements.

In traditional Drupal, all of Drupal's usual responsibilities stay intact, as Drupal is a monolithic system and therefore maintains complete control over the presentation and data layers. Traditional Drupal remains an excellent choice for editors who need full control over the visual elements on the page, with access to features such as in-place editing and layout management. This is Drupal as we have known it all along. Because the benefits are real, this is still how most new content management projects are built.

Sometimes, JavaScript is required to deliver a highly interactive end-user experience. In this case, a decoupled approach becomes required. In progressively decoupled Drupal, a JavaScript framework is layered on top of the existing Drupal front end. This JavaScript might be responsible for nothing more than rendering a single block or component on a page, or it may render everything within the page body. The progressive decoupling paradigm lies on a spectrum; the less of the page dedicated to JavaScript, the more editors can control the page through Drupal's administrative capabilities.

Up until this year, fully decoupled Drupal was a single category of decoupled Drupal architecture that reflects a full separation of concerns between the presentation layer and all other aspects of the CMS. In this scenario, the CMS becomes a data provider, and a JavaScript application with server-side rendering becomes responsible for all rendering and markup, communicating with Drupal via web service APIs. Though key functionality like in-place editing and layout management are unavailable, fully decoupled Drupal is appealing for developers who want greater control over the front end and who are already experienced with building applications in frameworks like Angular, React, Vue.js, etc.

Over the last year, fully decoupled Drupal has branched into two separate paradigms due to the increasing complexity of JavaScript development. The so-called JAMstack (JavaScript, APIs, Markup) introduces a new approach: fully decoupled static sites. The primary reason for static sites is improved performance, security, and reduced complexity for developers. A static site generator like Gatsby will retrieve content from Drupal, generate a static website, and deploy that static site to a CDN, usually through a specialized cloud provider such as Netlify.

What do you intend to build?

The essential question, as always, is what you're trying to build. Here is updated advice for architects exploring decoupled Drupal in 2019:

  1. If your intention is to build a single standalone website or web application, choosing decoupled Drupal may or may not be the right choice, depending on the features your developers and editors see as must-haves.
  2. If your intention is to build multiple web experiences (websites or web applications), you can use a decoupled Drupal instance either as a) a content repository without its own public-facing front end or b) a traditional website that acts simultaneously as a content repository. Depending on how dynamic your application needs to be, you can choose a JavaScript framework for highly interactive applications or a static site generator for mostly static websites.
  3. If your intention is to build multiple non-web experiences (native mobile or IoT applications), you can leverage decoupled Drupal to expose web service APIs and consume that Drupal site as a content repository without its own public-facing front end.

What makes Drupal so powerful is that it supports all of these use cases. Drupal makes it simple to build decoupled Drupal thanks to widely recognized standards such as JSON:API, GraphQL, OpenAPI, and CouchDB. In the end, it is your technical requirements that will decide whether decoupled Drupal should be your next architecture.

In addition to technical requirements, organizational factors often come into play as well. For instance, if it is proving difficult to find talented front-end Drupal developers with Twig knowledge, it may make more sense to hire more affordable JavaScript developers instead and build a fully decoupled implementation.

Are there things you can't live without?

As I wrote last year, the most important aspect of any decision when it comes to decoupling Drupal is the list of features your project requires; the needs of editors and developers have to be carefully considered. It is a critical step in your evaluation process to weigh the different advantages and disadvantages. Every project should embark on a clear-eyed assessment of its organization-wide needs.

Many editorial and marketing teams select a particular CMS because of its layout capabilities and rich editing functionality. Drupal, for example, gives editors the ability to build layouts in the browser and drop-and-drag components into it, all without needing a developer to do it for them. Although it is possible to rebuild many of the features available in a CMS on a consumer application, this can be a time-consuming and expensive process.

In recent years, the developer experience has also become an important consideration, but not in the ways that we might expect. While the many changes in the JavaScript landscape are one of the motivations for developers to prefer decoupled Drupal, the fact that there are now multiple ways to write front ends for Drupal makes it easier to find people to work on decoupled Drupal projects. As an example, many organizations are finding it difficult to find affordable front-end Drupal developers experienced in Twig. Moving to a JavaScript-driven front end can resolve some of these resourcing challenges.

This balancing act between the requirements that developers prioritize and those that editors prioritize will guide you to the correct approach for your needs. If you are part of an organization that is mostly editorial, decoupled Drupal could be problematic, because it reduces the amount of control editors have over the presentation of their content. By the same token, if you are part of an organization with more developer resources, fully decoupled Drupal could potentially accelerate progress, with the warning that many mission-critical editorial features disappear.

Current and future trends to consider Over the past year, JavaScript frameworks have become more complex, while static site generators have become less complex.

One of the common complaints I have heard about the JavaScript landscape is that it shows fragmentation and a lack of cohesion due to increasing complexity. This has been a driving force for static site generators. Whereas two years ago, most JavaScript developers would have chosen a fully functional framework like Angular or Ember to create even simple websites, today they might choose a static site generator instead. A static site generator still allows them to use JavaScript, but it is simpler because performance considerations and build processes are offloaded to hosted services rather than the responsibility of developers.

I predict that static site generators will gain momentum in the coming year due to the positive developer experience they provide. Static site generators are also attracting a middle ground of both more experienced and less experienced developers.

Conclusion

Drupal continues to be an ideal choice for decoupled CMS architectures, and it is only getting better. The API-first initiative is making good progress on preparing the JSON:API module for inclusion in Drupal core, and the Admin UI and JavaScript Modernization initiative is working to dogfood Drupal's web services with a reinvented administrative interface. Drupal's support for GraphQL continues to improve, and now there is even a book on the subject of decoupled Drupal. It's clear that developers today have a wide range of ways to work with the rich features Drupal has to offer for decoupled architectures.

With the introduction of fully decoupled static sites as an another architectural paradigm that developers can select, there is an even wider variety of architectural possibilities than before. It means that the spectrum of decoupled Drupal approaches I defined last year has become even more extensive. This flexibility continues to define Drupal as an excellent CMS for both traditional and decoupled approaches, with features that go well beyond Drupal's competitors, including WordPress, Sitecore and Adobe. Regardless of the makeup of your team or the needs of your organization, Drupal has a solution for you.

Special thanks to Preston So for co-authoring this blog post and to Angie Byron, Chris Hamper, Gabe Sullice, Lauri Eskola, Ted Bowman, and Wim Leers for their feedback during the writing process.

Accessible version of flowchart

This is an accessible and described version of the flowchart images earlier in this blog post. First, let us list the available architectural choices:

  • Coupled. Use Drupal as is without additional JavaScript (and as a content repository for other consumers).
  • Progressively decoupled. Use Drupal for initial rendering with JavaScript on top (and as a content repository for other consumers).
  • Fully decoupled static site. Use Drupal as a data source for a static site generator and, if needed, deploy to a JAMstack hosting platform.
  • Fully decoupled app. Use Drupal as a content repository accessed by other consumers (if JavaScript, use Node.js for server-side rendering).

Second, ask the question "What do you intend to build?" and choose among the answers "One experience" or "Multiple experiences".

If you are building one experience, ask the question "Is it a website or web application?" and choose among the answers "Yes, a single website or web application" or "No, Drupal as a repository for non-web applications only".

If you are building multiple experiences instead, ask the question "Is it a website or web application?" with the answers "Yes, Drupal as website and repository" or "No, Drupal as a repository for non-web applications only".

If your answer to the previous question was "No", then you should build a fully decoupled application, and your decision is complete. If your answer to the previous question was "Yes", then ask the question "Are there things the project cannot live without?"

Both editorial and developer needs are things that projects cannot live without, and here are the questions you need to ask about your project:

Editorial needs
  • Do editors need to manipulate page content and layout without a developer?
  • Do editors need in-context tools like in-place editing, contextual links, and toolbar?
  • Do editors need to preview unpublished content without custom development?
  • Do editors need content to be accessible by default like in Drupal's HTML?
Developer needs
  • Do developers need to have control over visual presentation instead of editors?
  • Do developers need server-side rendering or Node.js build features?
  • Do developers need JSON from APIs and to write JavaScript for the front end?
  • Do developers need data security driven by a publicly inaccessible CMS?

If, after asking all of these questions about things your project cannot live without, your answers show that your requirements reflect a mix of both editorial and developer needs, you should consider a progressively decoupled implementation, and your decision is complete.

If your answers to the questions about things your project cannot live without show that your requirements reflect purely developer needs, then ask the question "Is it a static website or a dynamic web application?" and choose among the answers "Static" or "Dynamic." If your answer to the previous question was "Static", you should build a fully decoupled static site, and your decision is complete. If your answer to the previous question was "Dynamic", you should build a fully decoupled app, and your decision is complete.

If your answers to the questions about things your project cannot live without show that your requirements reflect purely editorial needs, then ask two questions. Ask the first question, "Are there parts of the page that need JavaScript-driven interactions?" and choose among the answers "Yes" or "No." If your answer to the first question was "Yes", then you should consider a progressively decoupled implementation, and your decision is complete. If your answer to the first question was "No", then you should build a coupled Drupal site, and your decision is complete.

Then, ask the second question, "Do you need to access multiple data sources via API?" and choose among the answers "Yes" or "No." If your answer to the second question was "Yes", then you should consider a progressively decoupled implementation, and your decision is complete. If your answer to the second question was "No", then you should build a coupled Drupal site, and your decision is complete.

Evolving Web: Insights Into The New Drupal Admin UI Design

Jue, 01/24/2019 - 12:17

We at Evolving Web are really excited to see the progress being made on improving the Drupal admin UI. As a designer, I’m curious about the process that drives such a huge project. I talked to the designer in charge of the refreshed interface, Cristina Chumillas, and got super interesting insights into what’s behind the new design.
 

Claro – fresh and clear

So far, Cristina and the team developed a new theme which is called “Claro”. The main UX problems in the existing admin UI have not been addressed yet. However, the visual refresh is already a great improvement! In Spanish, “Claro” means “clear” and this seems to be the main motivation.

The old admin interface (left) and the new UI design (right).

I especially like the new colour palette that is a literal refresh with grey tones that are slightly bluish and a primary blue that is very lively. Compared to the old warm colour scheme, this simple step results in a much more modern look. The contrast has been increased a bit, which has several positive effects. It helps create a clear hierarchy and, of course, it helps make the interface more accessible. 

Interaction Design Challenges

I asked Cristina about the biggest challenge in the redesign. She said that complying with the latest accessibility standards was a tough one. 

“We are not designing for a private company, we are designing for Drupal and this means for anyone. The design has to be accessible for anyone.”

One example Cristina gave me was the form field designs. The initial form fields were similar to those in the Material Design system, with the label inside the input field. Once you select the field, the label floats to the top. It is an elegant technique that has become popular over the last few years. However, Cristina remarked that this kind of animated form design caused a problem with accessibility.

“We decided not to implement something that is super fancy.”

I appreciate the fact that the team behind the new Drupal design puts the user front and centre. The purpose of the redesign is not to create something original for the sake of being extraordinary. On the contrary, the goal is a clear design that prefers well-known design patterns over personality. This doesn’t mean that they kept the old form UI, which was mainly the browser default. The new form design is simple, but clear and therefore very usable.
 

Form field examples of the old UI (left) and of the new design system (right).

  Hierarchy & Proportions

The new UI system is extensive. It includes different states of interactive elements which results in a very consistent design from page to page. Sometimes, these little details make a huge difference. Let’s compare the old and the new second-level of the toolbar. The size ratio between the font size and the icon is not very balanced in the current UI. The chevron buttons have the heaviest visual weight which makes it difficult for the active page to stand out. 
 

Old second level toolbar (left) and new toolbar (right)

The new design uses the primary blue for highlighting active states. The chevrons are simple and don’t draw too much attention. The third-level of the menu is visually separated by a light blue background which also communicates depth.
 

Typography – Fluid and Flexible

I asked Cristina what she enjoyed most during this project. She didn’t have to think long:

“Typography! – Something that I’m really looking forward to implementing is Fluid Typography.”

Fluid Typography is a CSS trick which adjusts the font size and line height based on screen size. Instead of jumping from one size to the next bigger size at a breakpoint, the changes are fluid. This creates a really smooth responsive web experience.

Image credits: css-tricks.com/snippets/css/fluid-typography

Cristina and her team decided to use system fonts instead of a brand typeface in the new UI. She told me that it’s not about branding when you create a functional user interface. They didn’t want the typeface to take too much attention. Cristina pointed out that it is the functionality and usability of software like Drupal that counts. A smooth user experience with the application itself is more important than the branding. Besides, other elements such as the colour palette help with the recognition of the brand.

“Using system fonts feels more natural, more like working with your system and for the user it is not really important that it is Drupal or something else. It is just a tool.”

System font examples (Apple, Windows Vista and KDE)

Another reason for the use of system fonts, Cristina told me, is that sometimes the font is changed to the system font anyway, for instance in other languages that are not included in the character set. Depending on the language, the range of word length is huge as well. When designing an interface like Drupal, you have to keep it flexible anyway.

“There are some languages that are short, and then there is German…” 

As a last question, I asked Cristina, if she had one ultimate tip for other designers to improve their UI design. Her advice was: “Keep in mind that when we are dealing with content management UI, it is not about advertising, not about branding. UI should not be invisible, but it should serve a purpose.” 
“It should serve the user needs?” I suggested.
“Exactly! The [admin] UI should be useful for creating content – in our case, because that’s what Drupal is for – instead of being super fancy.”
 

About Cristina and the team

Cristina Chumillas is a very experienced designer with a background in graphic design and frontend development. She has been active in the Drupal community for many years and works as Creative Director and partner at Ymbra, a Drupal web agency based in Barcelona. The other designers contributing to the Claro theme are Sascha Eggenberger, Archita Arora as well as Dennis Cohn.

Next steps

Following the work on these visual improvements, the team will continue with this user-centered approach and address functionality issues. Suzanne and I helped figure out usability problems in different CMS’s in a comparative study in November and are currently working on a follow-up study to gather more data about how editors create more complex content. Cristina told me that our findings will help guide the the user experience of the Drupal admin interface. We can’t wait to see the results of the next steps!

 

+ more awesome articles by Evolving Web

OpenSense Labs: Blend of VueJS and Drupal

Jue, 01/24/2019 - 11:55
Blend of VueJS and Drupal Shankar Thu, 01/24/2019 - 19:25

That’s a beautiful view!”, you exclaim when you witness the sunset while standing on a beach with waves touching your feet. That is when you come out of the rut, leave behind the humdrum life of city and ‘really’ feel a natural beauty. There is another view in the digital landscape that will make you exclaim, “wow!”, and that is Vue.


Vue.js is fantastic for developers to build applications faster and make it more attractive and user-friendly. In combination with Drupal, one of the leading open source content management systems, Vue JS can be a brilliant option for web development needs.

A trip down memory lane: JavaScript frameworks

JavaScript framework is great for creating modern applications. There is an interesting piece from freeCodeCamp on JavaScript’s development and how it came through.

Browsers that we see today are did not have the sort of functionalities until the early 2000s. They were much less powerful and, performance-wise, there was no feasibility in creating intricate applications inside them.

Introduction of Google Maps and Gmail, that ran inside the browser, started bringing in the much-needed change. Asynchronous network requests were made a reality by Ajax. Eventually, development started happening on top of the web platform while the platform itself - that constitute browsers, the web standards, the browser APIs, and the JavaScript language - was being worked upon by engineers.

First major projects developed upon JavaScript were libraries like jQuery and Mootools that offered a nicer API for interacting with the browser in addition to the provision for solutions to bugs and inconsistencies among numerous browsers. Then, Backbone, Ember, Knockout among others burst onto the scene as modern JavaScript frameworks followed by React, Angular and Vue which have gained popularity in recent times.

The rise of VueJS


VueJS is one of the popular JavaScript frameworks. The official site of VueJS states that it is a progressive JavaScript framework that is used for developing user interfaces. In complete contrast to monolithic frameworks, it is incrementally adoptable and its core library emphasises on the view layer and can be easily incorporated with other libraries or existing projects. It is an astounding solution for intricate single page applications when leveraged alongside modern tooling and supporting libraries.

The usage of VueJS has seen a tremendous rise over the years as represented in the graph below.

Usage statistics of VueJS | Source: BuiltWith

VueJS scores heavily when it comes to high traffic websites. Organisations in need of a web development solution that can scale well during a high spike in traffic are opting for VueJS as can be seen in the graphical representation below.


Meritorious features of VueJS

Following are some of the benefits of VueJS:

Smaller in Size

A JavaScript framework triumph depends upon its size. Size of the JavaScript framework is directly proportional to its usage. With that being said, VueJS is very beneficial with its small size. The size of the VueJS framework is around 18-21KB which means it does not take much of your time while downloading and using it. Small size has no effect on the speed as it is fast and snappy.

Easy development

Adding Vue to an existing web project is quite easy and you can begin coding very swiftly without the need for knowing anything about JSX, ES2015 or build systems to get started. Familiarity with HTML and JavaScript in addition to reading their guide can assist in building something basic within a day that is very advantageous for a fast-paced development team where you are required to pick up something very quickly.

Moreover, it has a simple structure which is great for both small and large scale template development and saves a lot of time as a result. You can even trace the blocks with errors due to its simple structure.

Easy integration

It facilitates developers while integrating with existing applications which makes it a great prospect for developing new web applications and changing the pre-existing applications. The integration is possible because it has components for everything.

Exhaustive Documentation

The documentation of VueJS is very detailed, simple to understand and constitutes several code examples. It has a growing community of developers that can assist when needed.

Immense flexibility

It is simpler to write an app with VueJS swiftly and run it straight from the browser. Or you can even develop an intricate application leveraging ES6, JXX, components, routing, bundling among others. You can even write a template in HTML or in JavaScript or you can use JSX. You get the liberty to structure the application in a way that suits you.

Model-view-viewmodel architecture

Its MVVM architecture (Model-view-viewmodel) helps in facilitating two-way communications for easy management of HTML blocks.

Implementing VueJS with Drupal

Like VueJS, Drupal is very scalable and has been powering high-traffic websites around the world. It also has been outperforming other leading content management frameworks in this criteria.


The blend of Drupal and VueJS, which are both preferred for their scalability, can be a remarkable option. 

One of the ways of utilising VueJS with Drupal is the development of single page application as we have discussed in an earlier blog. It involves the installation of Drupal 8 on the local system followed by the creation of custom content types, adding views, and enabling REST API.

Then, you can start building front end with VueJS and create single page application. This would involve setting up of Vue project with Vue CLI. Once this is done, the addition of Vue router and Vue resource is performed. Vue router, the official router for VueJS, deeply integrates with VueJS core is similar to the angular router (of Angular JS) and react router (of React JS). Vue resource is the plugin for VueJS that offers services for making web requests and govern responses. Then, you can start modifying main.js file to use Vue routers and Vue resources and modify the app.js to work with the router followed by setting up of app components and routers.

Use case

Arbetsförmedlingen, Swedish Public Employment Service, benefitted from the amalgamation of Drupal and VueJS. Drupal Europe 2018 had a session that talked about how a video platform that was built for the Swedish government.


The platform used podcasts, video on demand and live broadcast for the dissemination of their content. They needed a new platform where these different sorts of media could be imported and metadata could be added for easily grouping them and filtering them out.

Drupal was the ultimate choice because of its great content management system, robust multilingual support, user management, and open source platform. Being lightweight with a production-ready build, VueJS was chosen as the desired JavaScript framework. Its compatibility with twig was a bonus. So, development recipe constituted Drupal, the combination of VueJS and twig and an API endpoint.

RESTful Web Services and Serialisation modules were enabled that gave the ability to create normal views as REST export and Axios, a promise-based HTTP client that has an easy-to-use API and can be leveraged in both the browser and NodeJS, was used for the consumption of data. Theme structure comprised of the twig, JS and CSS. Pluggable VueJs components were utilised and event handling configuration was shown through ‘Load More’ button.

Conclusion

The amalgam of Drupal and VueJS can be a rewarding solution that can help fulfil your digital transformation dreams.

We are devoted to providing ambitious digital experience to our partners through a suite of services.

Ping us at hello@opensenselabs.com to get the best out of Drupal and VueJS amalgamation.

blog banner blog image VueJS Drupal 8 Blog Type Articles Is it a good read ? On

Promet Source: Better Instructions for Your Drupal Content Types

Mié, 01/23/2019 - 17:40
Besides Title, the most common field label found on a content type form is Body. Of course, this is where you place the body of your content. It’s your blog post, your how-to instructions, or maybe an event description. You know exactly what needs to be provided in this field because you are the trained author. What happens when the scenario includes many authors with varied skills? Without clearly visible instructions for the form and the form fields, content authors can make mistakes. There are four default features in Drupal 8 that provide instructions for content authors.

OPTASY: Progressively Decoupled Drupal: Moving Towards a Standard Workflow

Mié, 01/23/2019 - 15:11
Progressively Decoupled Drupal: Moving Towards a Standard Workflow silviu.serdaru Wed, 01/23/2019 - 17:11

Progressively decoupled Drupal has gone from concept to buzzword. Until recently, when we've started to witness sustained efforts being made to set up a standard workflow for implementing this architecture.

New dedicated modules have been developed to fit those use cases where just a few particular blocks, affecting the website's overall performance, need to be decoupled. All while preserving Drupal's standard robust features.

Features too famous among content editors and site builders to be sacrificed in the name of high speed and rich UX. 

We've gradually shifted focus from “Why would I choose progressive decoupling over a headless CMS?” to:

Mediacurrent: Contrib Half Hour updates for 2019

Mié, 01/23/2019 - 14:40

Just over a year ago I decided to repurpose an internal contrib-focused meeting and make an open meeting to support contributing to Drupal, called the Contrib Half Hour. Along the way we moved its time a little later to avoid conflicting with another important community initiative and then restructured it to add focused meetings for certain topics. To make things even better, almost all meetings have been recorded and uploaded to our Youtube channel. 2019 is going to see some additional changes that I'm excited to start on.

Our Q&A have issues

Throughout the year it became apparent that there was a huge overlap between the Q&A meetings, where we'd focus on general questions and discussions from the community, and the issues lab, where we'd focus on specific drupal.org project issues. While there's definitely a case for both, the overlap became somewhat naturally as the Q&A days had us often look at Drupal issues.

As a result of this we're going to combine the Q&A and Issues Lab days into one that'll be more open ended, letting us focus on general discussions some days and specific issues other days.

The testing shall continue until code improves

We're also continuing our dedication to helping people learn how to write code tests for their modules and themes. While during 2018 we focused on functional testing for Drupal 7 and 8, I'm aiming to expand our coverage (ba-dum-dum) in 2019 to also include unit testing.

I'd also like to open an invitation for folks to join our testing lab who are starting to write tests to join our labs where we'll be able to help.

Upgrade Lab: Time to upgrade

It was announced late last year that Drupal 9 will be released in June 2020 and that Drupal 7 and 8 will reach their end-of-life in November 2021. The main driving factor behind these dates is that the various libraries Drupal 7 and 8 depend upon will all have reached their end-of-life in November 2021 and so will no longer receive security updates from their respective maintainers. To avoid needing to come up with a plan to provide security coverage for a huge number of out-of-date 3rd party libraries, the Drupal core maintainers are dropping support when the other libraries also stop being supported.

It was also revealed that the usual upgrade anxiety for major releases of Drupal (5 to 6, 6 to 7, etc) would not be the case for Drupal 9. The plan is two release Drupal 9.0.0 and the final minor release of Drupal 8 on the same day, with the only difference being that all deprecated D8 APIs are removed from D9. As a result it will be relatively easy to upgrade from Drupal 8 to 9, “just” update all contrib code and custom code to no longer use the deprecated APIs along the way, and in theory everything should just work.

With this in mind we think it's time for people running Drupal 6 and 7 sites to start looking to upgrade to Drupal 8. Towards that goal we're going to have a regular meeting where we look at the steps to upgrade a site to Drupal 8 using the bundled Migrate system. We'll look at what's involved, how it works, how to plan for it, and how to help contributed modules support Drupal 8's upgrade solution. I'm intending that we'll be able to collaborate on improving both core and contrib's upgrade functionality, and in so doing help all sites looking to upgrade. I'm also hoping that we might be able to provide some assistance to folks attempting custom upgrades using Migrate's APIs, but we'll see how it goes.

Schedule

Our schedule for the next few months looks like this:

  • January 3: Q&A
  • January 10: Turning custom code into OSS
  • January 17: Q & A & Issues
  • January 24: Testing Lab
  • January 31: Upgrade Lab
  • February 7: Presentation TBD
  • February 14: Q & A & Issues
  • February 21: Testing Lab
  • February 28: Upgrade Lab
  • March 7: Presentation TBD
  • March 14: Q & A & Issues
  • March 21: Testing Lab
  • March 28: No meeting
  • April 4: Upgrade Lab
  • April 11: Presentation TBD
  • April 18: Q & A & Issues
  • April 25: Testing Lab
  • May 2: Upgrade Lab
  • May 9: Presentation TBD
  • May 16: Q & A & Issues
  • May 23: Testing Lab
  • May 30: Upgrade Lab
Same Bat Time!

We're going to continue meetings at the same time each month, using the same video conferencing provider:

And remember, if you're not able to join us then you can always catch up later as all meetings are recorded, when I don't forget to hit the record button that is.

See you then!

Chromatic: Getting Ready for the Drupal Global Contribution Weekend

Mié, 01/23/2019 - 14:26

This coming weekend is the Drupal Global Contribution Weekend where small local contribution groups volunteer their Drupal development at the same time throughout the world. This year there are local groups gathering in Canada, England, Germany, India, Russia, Spain, and the United States.

TIP Solutions: Hotellinx ERP system to Drupal Commerce integration

Mié, 01/23/2019 - 10:24
The task was to integrate an ERP system (more specific Hotel management system called Hotellinx) which is (and should always stay or be) a single source of truth (SSOT) for the products they have and administer. If you want to sell these products from another system like a webshop you need to transfer the data there to showcase your goods to customers. Another way of explaining that is to say the webshop is only to make a purchase but all the data is stored to the ERP system or SSOT. Planet Drupal Drupal 8 hotellinx Integration Commerce

ADCI Solutions: Getting started REST API with Symfony 4

Mié, 01/23/2019 - 08:24

We fell in love with Symfony back then when its components were added to Drupal 8. We keep on learning and teaching how to use this powerful PHP framework for projects with complicated business logic.
In this Symfony 4 tutorial, we will create a basic server back-end structure for your application using the REST API architecture style. 

Sounds fun? You may find the article here.  

 

OSTraining: How to Rewrite the Output of Views Fields in Drupal

Mié, 01/23/2019 - 08:06

One of our customers asked how to tweak the fields of a table output by Views to give the table a cleaner look.

They were looking for a way to merge the fields of the first and second columns. They also wanted to display the file download link just with an icon.

There are a couple of ways to achieve this. One of them is to rewrite the output of Views’ fields.

This tutorial will explain how to rewrite the results of any Views’ field. We can rewrite the results, regardless of what display the view is using (table, list, grid, etc).

Virtuoso Performance: Announcing the Soong project - developing a general-purpose ETL framework

Mar, 01/22/2019 - 18:10
Announcing the Soong project - developing a general-purpose ETL framework mikeryan Tuesday, January 22, 2019 - 02:10pm

I'd like to invite members of the open-source community, particularly (but not exclusively) those involved with PHP, to join in designing and developing a general-purpose ETL framework for data migration. The vendor name for packaging components of this project is soong, and git repos for existing components are under the GitLab account "soongetl".

Note: Finally having finished composition of this lengthy monologue, it's clear to me that it's very ambitious (some might say arrogant) of me to write with the expectation that this will grow into a large and robust open-source ecosystem. Very well - it is ambitious, and the effort may very well fall flat on its face. C'est la vie...

Who am I?

I'm Mike Ryan - a lot of people in the Drupal community know me, but not so much the wider open-source community. Almost eleven years ago at a Drupal meetup in Boston, amongst general agreement that everyone hates to do data migration, Moshe Weitzman looked across the table at me and said "there's an opportunity here." Since then data migration into Drupal has been the primary focus of my professional life, first in partnership with Moshe, then as an Acquia employee and finally as a solo consultant. Over the years I've created several migration-related contrib modules for Drupal, was part of the team integrating migration into Drupal core for D8, and have been involved in dozens of real-world migration projects.

Why am I doing this? I think we can do better

Just within Drupal, the migration framework can be improved:

  1. Each step of Drupal migration support has been a port of the previous - from the hook-based Drupal 6 version, to the inheritence-and-composition model in Drupal 7, to the plugin-based system in Drupal 8, technical debt has accumulated. I've wanted for a while to start over with a clean slate - given my experience (and others), what would we do differently starting from scratch? Can we step back and re-examine the assumptions we've been carrying forward?
  2. At a specific technical level, the biggest itch I've wanted to scratch is decoupling the components. Within the migration system as it is in D8 today, pretty much every component knows everything about every other component. At one point we had a destination plugin which was using some of the migration's source plugin configuration - that one made my eye twitch!
  3. There's also the coupling of the migration system with Drupal - in particular, migration classes *are* Drupal plugins (i.e., their interfaces extend PluginInspectionInterface) rather than being *managed by* Drupal plugins. I would like to see migration classes be all about migration, rather than worry about being plugins as well. And once the basic migration classes are no longer Drupal plugins, then it's a small step to them being entirely independent of Drupal...
The larger PHP community

With Drupal 8, we’ve often talked about “getting off the island” in terms of benefiting from much fine PHP work done outside of the Drupal community. We haven’t talked so much about going in the opposite direction - making our own fine work available for use beyond Drupal. To my knowledge, the only published example of this so far is Kris Vanderwater (EclipseGC) with the plugin library.

Likewise, we Drupal developers don’t have a monopoly on good migration ideas - by moving the general-purpose aspects of migration into a separate open source project, we have the opportunity to benefit from new ideas and new talent.

The community we build

The major key to success for any large open-source project like this is a thriving community. After seeing open-source projects like Drupal grow organically - and face growing pains as they find themselves dealing with community problems reactively rather than proactively - if a community does form around this project, I would like to establish a supportive and welcoming tone from the beginning.

Diversity in particular remains an issue in the tech industry in general, and open-source especially - and a lack of diversity is difficult to correct after the fact. In building a community around this framework, my hope is that we draw a diverse set of developers in the beginning, in the hopes that seeding the garden well will be, if not self-sustaining, at least more sustainable. How to do that, I'm not certain - a concerted outreach effort could easily end up looking like Pokemon Go, searching for unique creatures to collect. Apart from starting with a good Code of Conduct, I'm open to suggestions!

Another aspect of community-building is providing opportunities for relative novices (whether new to open-source development, new to PHP, or new to migration). The proposed architecture involves myriad small, well-focused packages - an extractor here, a set of related transformers there, integrations for specific frameworks and APIs... Individual transformers, in particular, will generally be very simple. This ecosystem thus will provide ample opportunities for novices to gain experience with mentorship and also establish an online presence.

Now, all that being said, what about The Ethics of Unpaid Labor and the OSS Community (also see the recent Twitter discussion in the Drupal community)? In reaching out to underrepresented groups and to novices, we are reaching out to the people who have the least ability to work on open source for free. One way to ameliorate this effect may be to explicitly try to draw in students - whether in formal programs or teaching themselves software development - who will benefit from some free practical education and mentorship. Down the road, if this framework does start being adopted in real-world applications, we can look at ways to get sponsorships for people who maintain projects within the ecosystem. At any rate, as the community here grows I expect this will be an ongoing conversation.

Selfishness

Yes, I'm willing to cop to selfish reasons to pursue this.

  1. Simple ego: I'm proud of the work I've done on migration in Drupal, and think it can be useful on a larger stage. Being old enough to see retirement on the horizon, I admit I'm thinking of this as my magnum opus - the last major contribution I make to open source. I would love to leave behind a significant piece of quality software with a vital community behind it.
  2. Money: I've done fine as a Drupal data migration specialist. I hope to do better by expanding my market beyond Drupal, working on a wider variety of migration projects. Yes, retirement is on the horizon but, given earlier attempts at consulting which went less well than my "migration period" has, my funds put that horizon farther out than I'd like...
What's done so far?

Early last year I started playing around with a proof-of-concept in a single repo, getting a single basic ETL migration scenario running with a decoupled class structure based on the basic architecture of the Drupal migration system. Much of the work after getting the initial POC running was figuring out appropriate boundaries between components, and gradually introducing features beyond the most basic ones I started with. And then breaking pieces out into separate source repos, and figuring out those boundaries.

My role

This will certainly change according to the number and skills of contributors who join into this effort (assuming there are some!), but what I'm aiming for in terms of my own role:

  1. Primary architect of version 1 of Soong. This would mean being the primary maintainer of architecture documentation and the repository of central interfaces/base classes. Per "selfishness" above - I have an architectural vision I want to see brought to fruition. Others may take it in different directions after that, but V1 is mine! tl;dr - I don't want to be BDFL; I do want to be BDF1.
  2. Community leader. Per "community" above, I have a vision for building a diverse and vibrant open-source community from the ground up. Unlike the technical architecture, however, this plays less to my strengths, so I will be happy to defer as better-suited people show leadership in the community.
  3. Mentorship. I'd like to help people up their development skills, their open-source involvement, and their understanding of the pits and perils of data migration.
Why did it take me so long?

After having it in the back of my head for a few years, I finally started creating repos and putting my thoughts into actual interfaces and classes several months ago. Why did I wait until now to share my work with the larger community? I certainly felt seen when I read this:

https://twitter.com/jessfraz/status/1063425181509652481

Frankly, there's an element of imposter syndrome here - I wanted to be sure I wasn't exposing any dumb ideas! Well, enough of that - instead, I now stipulate that you will find dumb things I did here, and ask that you help smartify them.

The architecture itself

There's a ways to go documenting the architecture as it is currently implemented in soong/soong, but right now it broadly looks like this:

  1. A Task accepts configuration defining a migration process, and implements operations - most notably migrate, but it may also support other operations like rollback, status, analyze, … The following steps describe the migrate operation.
  2. The task constructs the configured Extractor, which obtains data from a source such as a SQL query, a CSV file, an XML/JSON API, etc.
  3. Iterating over the extractor returns one DataRecord (collection of named DataProperty instances) at a time containing source data. The task creates an empty DataRecord representing the destination data.
  4. The task configuration defines a transform pipeline keyed by destination property names. For each of these properties, a sequence of one or more Transformer classes with corresponding configuration is invoked to determine the destination property value - usually, the first one will be configured to accept one or more source property names, and the results will be fed to subsequent transformers, with the final result assigned to the named property in the destination DataRecord.
  5. The destination DataRecord is passed to the configured Loader to be loaded into the destination store - a SQL database, a CSV file, etc.
  6. If an optional KeyMap is configured within the task, it is used to store the mapping from the source record's unique key to the destination record's unique key. This enables keyed relationships to be maintained even if keys change when migrating, as well as enabling rollback.

To try out a couple of working demos, git clone git@gitlab.com:soongetl/poc.git and follow the README.

Initial technical priorities
  1. One of those infamous hard problems in computer science is naming things. Before we go too far, let's figure out how best to name things - I think Extractor/Transformer/Loader are pretty solid, but let's discuss whether other components (like Task) could use better names. Also, let's decide what naming conventions for implementations should look like - e.g., should CSV extractor and loader classes both be named CSV (or for that matter, Csv) with namespaces alone distinguishing them, or should they be CSVExtractor and CSVLoader?
  2. The initial architecture, as I've said before, comes from my narrow experience in Drupal. I'm sure there are plenty of other good migration ideas out there - maybe there's even a package I've missed that's good enough that this effort would better be directed towards improving it rather than starting from scratch. I did do some research last year and did not find any PHP ETL packages that appeared to have wide adoption or as much flexibility, but with more eyes on it (eyes that have seen more beyond Drupal than I have) let's see if we can do a thorough review of prior art and see if there are some good ideas which may influence this effort. And let's look beyond PHP as well - are there ETL frameworks written in other object-oriented languages which may provide some architectural inspiration?
  3. Review the boilerplate for Soong code repos (based on https://github.com/thephpleague/skeleton) - let's go over what we've got there (especially the code of conduct and contributing guidelines).
  4. Test all the things! Before adding new stuff, we need to add tests for the existing components, and set up automated testing on Gitlab.
Technical goals
  1. For V1, require PHP 7.1 and leverage strict type checking. I expect future versions to require PHP 7.4 and leverage typed object properties.
  2. The central interface package soong/soong ideally should not depend on anything other than PSR interfaces. It should be approached as if it were a PSR itself - a completely general interface for ETL functionality not dependent on any non-standard interfaces.
Conclusion

Again, I know I am getting way ahead of myself here by imagining an active open-source community will quickly spring up here. I have talked to Drupal people about my ideas on occasion, and I expect there will be some interest there, but I very much hope other open-source developers can join this effort and provide different perspectives. I do believe strongly that a standard ETL library with a core of simple standard interfaces (making a simple move-my-stuff-from-here-to-there application a breeze) plus the flexibility to build complex systems to handle many types of data will be extremely valuable across many domains.

If I may try your patience a bit longer - I've spent a substantial portion of my time since my last contract pulling these thoughts together, and I am now in need of paid work (contact me if you need some data migration done!). I may fantasize about being sponsored to work fulltime on Soong, or be hopeful there's someone with a project that they think will benefit from Soong and thus I can make progress here in the course of solving their migration problem. Realistically, my next contract (or employment) most likely will not involve Soong development, so once I'm working I won't have as much time to manage this project - let's hope plenty of people join in to pick up my slack!

If you've made it this far, thank you for your time and I look forward to your merge requests!

Tags Drupal Planet Drupal PHP Migration Use the Twitter thread below to comment on this post:

https://t.co/0uVJ13t8md

— Virtuoso Performance (@VirtPerformance) January 22, 2019

Manifesto: Grow as a Drupal developer: embrace the community!

Mar, 01/22/2019 - 12:24

So far in our series of posts about helping you become a better Drupal developer,  we’ve talked a lot about contribution from an individual point of view. But Drupal is community first! Even if you believe you’ve already reached your potential as a developer, remember people before you said and subscribed to the motto:  Come. Continue reading...

The post Grow as a Drupal developer: embrace the community! appeared first on Manifesto.

ComputerMinds.co.uk: Review driven development?

Mar, 01/22/2019 - 09:06

We've heard of test-driven development, behaviour-driven development, feature-driven development and someone has probably invented buzzword-driven development by now. Here's my own new buzzword phrase: review-driven development. At ComputerMinds, we aim to put our work through peer reviews to ensure quality and to share knowledge around the team. Chris has recently written about why and how we review our work. We took some time on our last team 'CMDay' to discuss how we could make doing peer reviews better. We found ourselves answering this question:

Why is reviewing hard? How can we make it easier?

We had recently run into a couple of specific scenarios that had triggered our discussion. For one, pressure to complete the work had meant reviews were rushed or incomplete. The other scenario had involved such a large set of code changes that reviewing them all at the end was almost impossible. I'm glad of the opportunity to reflect on our practice. Here are some of the points we have come away with - please add your own thoughts in the comments section below.

1. Coders, help your reviewers

The person that does the development work is the ideal person to make a review easy. The description field of a pull request can be used to write a summary of changes, and to show where the reviewer should start. They can provide links back to the ticket(s) in the project's issue tracking system (e.g. Redmine/Jira), and maybe copy across any relevant acceptance criteria. The coder can chase a colleague to get a review, and then chase them up to continue discussions, as it is inevitable that reviewers will have questions.

2. Small reviews are easier

Complicated changes may be just as daunting to review as to build. So break them up into smaller chunks that can be reviewed easier. This has the massive benefit of forcing a developer to really understand what they're doing. A divide & conquer approach can make for a better implementation and is often easier to maintain too, so the benefits aren't only felt by reviewers.

3. Review early & often

Some changes can get pretty big over time. They may not be easy to break up into separate chunks, but work on them could well be broken up into iterations, building on top of each other. Early iterations may be full of holes or @TODO comments, but they still reveal much about the developer's intentions & understanding. So the review process can start as early as the planning stage, even when there's no code to actually review. Then as the changes to code take shape, the developer can continually return to the same person every so often. They will have contextual knowledge growing as the changes grow, to understand what's going on, helping them provide a better review.

4. Anyone can review

Inevitably some colleagues are more experienced than others - but we believe reviews are best shared around. Whether talking about your own code, or understanding someone else's code, experience is spread across the team. Fresh eyes are sometimes all that's needed to spot issues. Other times, it's merely the act of putting your own work up for scrutiny that forces you to get things right.

5. Reviewers, be proactive!

Developers like to be working, not waiting for feedback. Once they've got someone to agree to review their work, they have probably moved onto solving their next problem. However well they may have written up their work, it's best for the reviewer to chase the developer and talk through the work, ideally face-to-face. Even if the reviewer then goes away to test the changes, or there's another delay, it's best for the reviewer to be as proactive as possible. Clarify as much as needed. Chase down the answers. Ask seemingly dumb questions. Especially if you trust the developer - that probably means you can learn something from them too!

6. Use the tools well

Some code changes can be ignored or skipped through easily. Things like the boilerplate code around features exports in Drupal 7, or changes to composer.lock files. Pointers from the developer to the reviewer of what files/changes are important are really helpful. Reviewers themselves can also get wise as to what things to focus on. Tools can help with this - hiding whitespace changes in diffs, the files tab of PRs on github, or three-way merge tools, for example. Screenshots or videos are essential for communicating between developer & reviewer about visual elements when they can't meet face-to-face.

7. What can we learn from drupal.org?

The patch-based workflow that we are forced to use on drupal.org doesn't get a lot of good press. (I'm super excited for the gitlab integration that will change this!) But it has stood the test of time. There are lessons we can draw from our time spent in its issue queues and contributing patches to core and contrib projects. For example, patches often go through two types of review, which I'd call 'focussed nitpicks' and the wider 'approach critiques'. It can be too tempting to write code to only fulfil precise acceptance criteria, or to pass tests - but reviewers are humans, each with their own perspectives to anticipate. Aiming for helpful reviews can be even more useful for all involved in the long-run than merely aiming to resolve a ticket.

8. Enforcing reviews

We tailor our workflow for each client and project - different amounts of testing, project management and process are appropriate for each one. So 'review-driven development' isn't a strict policy to be enforced, but a way of thinking about our work. When it is helpful, we use Github's functionality to protect branches and require reviews or merges via pull requests. This helps us to transparently deliver quality code. We also find this workflow particularly handy because we can broadcast notifications in Slack of new pull requests or merges that will trigger automatic deployments.

What holds you back from doing reviews? What makes a review easier?

I've only touched on some the things we've discussed and there's bound to be even more that we haven't thought of. Let us know what you do to improve peer reviewing in the comments!

Agiledrop.com Blog: Interview with Gabriele Maira of Manifesto Digital

Mar, 01/22/2019 - 05:46

Meet Gabriele Maira, also known as Gabi by friends and as Gambry by the Drupal community. With over 15 years of experience working with PHP and over 10 working with Drupal, Gabriele is currently the PHP/Drupal Practice lead at the London-based Manifesto Digital. Read about his beginnings with open source and why he thinks every Drupal developer should attend a Sprint at least once in their life.

READ MORE

OpenSense Labs: Extract advanced Solr features with Drupal

Mar, 01/22/2019 - 05:05
Extract advanced Solr features with Drupal Shankar Tue, 01/22/2019 - 12:35

Instances of advanced search can be seen through different things. Take space research for instance. In their perpetual effort to explore Universe and search for Earth-like planets or a star that is similar to our Sun, Scientists wind up discovering interesting things. NASA’s Hubble Space Telescope was used to spot a star called Icarus, named after Greek mythological figure, which is the most distant star ever viewed and is located halfway across the universe.


On the other side of the spectrum, Apache Solr is making huge strides with its advanced search capabilities. Enterprise-level search is a quintessential necessity for your online presence to be able to thrive in this digital age. Big organisations like Apple, Bloomberg, Marketo, Roku among others are opting for Apache Solr for its advanced search features. Amalgamation of Drupal and Apache Solr can be a remarkable solution for a magnificent digital presence.

Planting the seed in 2004

John Thuma, in one of his blog posts, stated that tracing the history of Apache Solr would take us back to the year 2004 when it was an in-house project at CNET Networks used for offering search functionalities for the company’s website. It, then, donated it to the Apache Software Foundation in 2006.

Later, the Apache Lucene and Solr projects combined in 2010 with Solr becoming a sub-project of Lucene. It has witnessed an awful lot of alterations since then and is now a very significant component in the market.

Uncloaking Apache Solr


As an enterprise-capable, open source search platform, Apache Solr is based on the Apache Lucene search library and is one of most widely deployed search platforms in the world.

Solr is a standalone enterprise search server with a REST-like API. You put documents in it (called "indexing") via JSON, XML, CSV or binary over HTTP. You query it via HTTP GET and receive JSON, XML, CSV or binary results. - Lucene.apache.org

It is written in Java and offers both a RESTful XML interface and a JSON API that enables the development of search applications. Its perpetual development by an enormous community of open source committers under the direction of the Apache Software Foundation has been a great boost.

Apache Solr is often debated alongside Elasticsearch. There is even a dedicated website called solr-vs-elasticsearch that compares both of them on various parameters. It states that both the solutions have support for integration with open source content management system like Drupal. It depends upon your organisation’s needs to select from either one of them.

For instance, if your team comprises a plentitude of Java programmers, or you already are using ZooKeeper and Java in your stack, you can opt for Apache Solr. On the contrary, if your team constitutes PHP/Ruby/Python/full stack programmers or you already are using Kibana/ ELK stack (Elasticsearch, Logstash, Kibana) for handling logs, you can choose Elasticsearch.

Characteristics of Apache Solr

Following are the features of Apache Solr:

Advanced search capabilities
  • Spectacular matching capabilities: Apache Solr is characterised by the advanced full-text search capabilities. It enables spectacular matching capabilities comprising of phrases, grouping, wildcards, joins and so on, across any data type.
  • A wide array of faceting algorithms: It has the support for faceted search and filtering that enables you to slice and dice your data as needed.
  • Location-based search: It offers out-of-the-box geospatial search functionalities.
  • Multi-tenant architecture: It offers multiple search indices that streamlines the process of segregating content and users.
  • Suggestions while querying: There is support for auto-complete while searching (typeahead search), spell checking and many more.
Scalability

It is optimised for the colossal spike in traffic. Also, Solr is built on Apache Zookeeper which makes it easy to scale up or down. It has in-built support for replication, distribution, rebalancing and fault tolerance.

Support for standards-based open interfaces and data formats

It uses the standards-based open interfaces like XML, JSON and HTTP. Furthermore, you do not have to waste time converting all the data to a common representation as Solr supports JSON, CSV, XML and many more out-of-the-box.

Responsive admin UI

It has the provision for an out-of-the-box admin user interface that makes it easier to administer your Solr instances.

Streamlined monitoring

Solr publishes truckload of metric data via JMX that assists you in getting more insights into your instances. Moreover, the logging is monitorable as the log files can be easily accessed from the admin interface.

Magnificent extensions

It has an extensible plugin architecture for making it simple to plugin both index and query time plugins. It also provides optional plugins for indexing rich content, detecting language, clustering search results amongst others.

Configuration management

Its flexibility and adaptability for easy configuration are top-notch. It also offers advanced configurable text analysis, that means, there is support for most of the widely spoken languages in the world and a plethora of analysis tools that makes the process of indexing and querying your content flexible.

Performance optimisation

It has been tuned to govern largest of sites and its out-of-the-box caches have fine-grained controls that assist in optimising performance.

Amazing Indexing capabilities

Solr leverages Lucene’s Near Real-Time Indexing capabilities that ensure that the user sees the content whenever he or she wants to. Also, its built-in Apache Tika simplifies the process of indexing rich content like Microsoft Word, Adobe PDF and many more.

Schema management

You can leverage Solr’s data-driven schemaless mode in the incipient stage of development and can lock it down during the time of production.

Security

Solr has robust built-in security like SSL (Secure Sockets Layer), Authentication and role-based authorisation.

Storage

Lucene’s advanced storage options like codecs, directories among others ensures that you can fine-tune your data storage needs that are applicable for your application.

Leverage Apache UIMA

Enhancement of content can be done with its advanced annotation engines. It incorporates Apache UIMA for leveraging NLP (Natural Language Processing) and other tools for your application.

Integrating Apache Solr with Drupal

Drupal’s impressive flexibility empowers digital innovation and gives the power to the users to build almost anything. It has the provision for integration of your website with Solr platform. Drupal’s Search API Solr Search module provides a Solr backend for the Drupal Search API module.

Drupal’s Search API Solr Search module provides a Solr backend for the Drupal Search API module.

To begin with, you need to have Apache Solr installed on your server. This is followed by the validation of the Solr server’s status using Terminal. It is succeeded by the installation of Search API Solr Search module using Composer.

Once the installation of Search API Solr Search module is done, the process of configuration of Solr ensues. This involves the creation of collection which is basically a logical index linked to a config set.

Source: OSTraining

Then, Drupal’s default search module is uninstalled for negating any performance issues and the Search API Solr Search module is enabled. You can, then, move on to the process of configuration of the Search API. Finally, you can test the Search API Solr Search module.

Source: OSTrainingCase study

The Rainforest Alliance (RA), which is an international non-profit organisation working towards the development of strong forests, healthy agricultural work landscapes, and burgeoning communities via creative collaboration, leveraged the power of Drupal to revamp their website with the help of a digital agency.


RA has built a repository of structured content for supporting its mission and the content is primarily exhibited as long-form text with a huge variety of metadata and assets associated with each part of the content. It wanted to revamp the site and enable the discovery of new content on the site with the help of the automatic selection of related content. It also required the advanced permission features and publishing workflows.

Drupal was great because of its deep integrations with Apache Solr that enabled nuanced content relation engine.

Drupal turned out to be an astounding choice for fulfilling RA’s requirement of portable and searchable content. It was also great because of its deep integrations with Apache Solr that enabled nuanced content relation engine. Solr was leveraged for powering various search interfaces. Furthermore, Drupal’s wonderful content workflow features made it a perfect choice.

Solr offered ‘more like this’ (MLT) functionality that was more robust than just tagging content and showing other content with the same taxonomy terms. Search API Solr Search module, which provides a Solr backend for the Search API module, was utilised for providing the interface to govern the servers and indexes. Then, with a custom block, MLT was leveraged for assisting the process generating related content lists.

Page manager module, in combination with Layout Plugin and Panels modules, was used to build specialised landing pages in the form of specialised page manager pages with many of them having their own layouts. Different modules were utilised from within the media ecosystem of Drupal were very beneficial in administering images, embedding videos, and so on. Entity Embed, Entity Browser and Inline Entity form were magnificent for a great editorial experience for content teams.

Conclusion

Apache Solr is a great solution for enabling enterprise-level search and can make a world of difference in combination with Drupal for your digital presence.

We have been empowering our partners in their efforts digital transformation dreams with our expertise in Drupal development.

Ping us at hello@opensenselabs.com to extract advanced Solr features with Drupal.

blog banner blog image Apache Solr Drupal Drupal 8 Elasticsearch Search API Search API Solr Search Blog Type Articles Is it a good read ? On

Páginas