Drupal

Chromatic: Code Standards: How Do We Implement Them?

Drupal Planet - Tue, 2016-07-12 09:36

This is the second post in a series about coding standards. In our first post, we talked about code standards and why they are so important. In this post, we’ll talk about how to implement Drupal coding standards in your projects.

Other posts in this series:

  1. Code Standards: What Are They?
  2. Code Standards: How Do We Implement Them?
  3. Code Standards: Formatting
  4. Code Standards: Documentation
  5. Code Standards: The t() function
  6. Code Standards: Object Oriented Coding & Drupal 8
Read the coding standards and keep them handy.

It’s a good idea to read over the Drupal coding standards so you have an idea of what’s expected. Even if you’re familiar with them, we can always use a refresher. They’re also a living document, so there’s a good chance something may have been changed or added since the last time you gave them a go-over. Use this post as a reason to read them again! Make sure you have them bookmarked for reference, as well. https://www.drupal.org/coding-standards

Set up your editor for success

The easiest way to keep your code clean and up to par is by having your editor do the work! There are a lot of editors out there, and even the ones that don’t have many bells and whistles can be set up to help you keep standards in mind when you’re coding.

Sublime Text

This post from Chris is a couple years old, and geared towards front-end developers, but has lots of great Sublime Text setup tips and plugins for every developer.

There’s some great info on drupal.org as well: https://www.drupal.org/node/1346890. Here you can find the basic configuration for adhering to Drupal coding standards, a script to set it up on OSX and Linux, and great plugins to help with development. Now you don’t need to worry about line length, spaces, tabs, line endings, and more. It’ll all be handled for you!

PhpStorm

If you’re using PhpStorm, their website has extensive instructions for getting set up with Drupal configuration here.

If you’re using another editor, you can see if it’s listed here: https://www.drupal.org/node/147789

If not, I’d suggest googling it, and if you don’t find instructions, create them and add them to the list!

Review your own code - Use coder

The easiest way to make sure you’re conforming to coding standards is to use a program like codesniffer. You can install coder, which is a Drupal module that allows you to check your code from the command line using custom rules and PHP Codesniffer. Here’s an example of what you might see:

Let’s walk through this screenshot.

  1. I’ve navigated to a module directory - here, I’m checking the countries module.
  2. The alias I have set up for codesniffer, using custom Drupal rules, is drupalcs.
  3. I want to test the file at tests/countries.test.
  4. Sometimes this command can take a little while. If it seems like it’s hanging, especially if you’ve checked a directory, it may be too much, so try a single file at a time.
  5. The first thing you’ll see is which file you checked, and the full path. Here, it’s /Applications/MAMP/htdocs/countries/tests/countries.test
  6. Next, you’ll see how many errors and warnings, and how many lines they affect - there can be multiple errors per line, and coder will catch them all.
  7. Next, each error or warning will be listed line by line.

I find it’s easiest to go in order, because sometimes one error causes others - coder can only understand so much, so if you have, for example, an array that has one line indented improperly, it may also think the subsequent lines are indented improperly, even if they’re correct.

Christopher did a great post on PHP Codesnifffer last year, check it out here.

Generally, you want to run coder every time you make a change, and before you commit your code or submit a patch. This way, you’re always writing clean code, and anyone reviewing your code is reviewing it for content, and they don’t have to worry about style. Of course, everyone is human and we all make mistakes. Sometimes you’ll push up a tiny change without running coder, and not realize there was a style issue. That’s why team code reviews are so important!

Team code reviews - make the time

The most successful teams build in time to review one another’s code. There’s no substitute for code reviews by another person, and making sure that you view them as an essential part of your process - the same goes for reviews on drupal.org. When planning time and resources for a project, make sure that there is time set aside for code reviews. When you’re working on contrib projects, make sure you take a look at issues marked "Need Review," and test them. If you want a way to dive into a project or just Drupal and contrib work in general, reviewing patches is a great way to get acclimated. You get exposed to other people’s code, and if you find something that needs to be corrected, that will stick with you and you’ll remember it.

Two things to remember when reviewing other people’s code, or when receiving reviews of your own:

  1. Treat others as you would like to be treated. Be kind, courteous, respectful, and constructive. Be aware of your tone. It’s easy to come off more harshly than you intended, especially when working quickly. Take just a second to re-read your comments, especially if you’re communicating with someone you’re not acquainted with.
  2. Take everything in stride, and don’t take it personally. Those reviewing your code want it to be good, and corrections aren’t a personal attack. This can be especially hard when you start out, and even after years, you can still get a comment that comes off in a way that hurts your feelings. Don’t dwell on it! Thank them, make the corrections, submit them, and chances are, they’ll thank you, too.

Now you know what code standards are, why they’re important, and how you can get started implementing them in your code. Set up your editor, install coder, and get ready for our next code standards post on formatting! We’ll talk about the nitty gritty of how you should format your Drupal code.

[1] Hero photo attribution: charlene mcbride

Categories: Drupal

Chromatic: Civil Comments Drupal Module

Drupal Planet - Tue, 2016-07-12 09:36

Civil Comments is a platform that brings real-world social cues to comments sections via crowd-sourced moderation and powerful community management tools. Civil Comments is the first commenting platform specifically designed to improve the way people treat each other online.

Unlike others who have thrown up their hands and accepted that the comments sections of the Internet would either be dominated by bullies and trolls, or become a moderation burden for a site's editors, the team at Civil is attempting to solve the problem with community moderation. It is an exciting new take on a widespread problem, and Chromatic is thrilled to bring Civil Comments integration to Drupal with a new contrib module.

It should be noted (and is on the project page!) that there is not currently a free version of Civil Comments. For the time being, it is only available with a subscription as Civil continues work on the platform, but from what I understand a free version is on the horizon.

A special thanks to Christopher Torgalson and Alanna Burke, whose contributions helped get this project off the ground!

Categories: Drupal

Code Enigma: Spinning up a CentOS server for Drupal

Drupal Planet - Tue, 2016-07-12 08:33
Spinning up a CentOS server for Drupal Language English Spinning up a CentOS server for Drupal

This blog post was originally going to be an email to someone who needed a bit of help getting set up. Then I realised it would be a nice blog. So here we are! CentOS and Drupal from the top.

Tue, 2016-07-12 16:33By greg

Before I start, I make no claim this is the best way to set up CentOS. I'm sure it isn't the only way, and I'm sure there will be other, more thorough, howto articles about the general setup of CentOS that are much better than this one. Heck, I don't even subscribe to CentOS (or RHEL) as the best distro for hosting Drupal (we usually use Debian), but that's debatable. What this blog is is a way to get going quick with a CentOS Linux server and Drupal.

On most virtualisation platforms you can probably choose a CentOS base image and start with an installed operating system. If you can't, or if this is a spare desktop computer or something, you'll need to download CentOS and make some install media. The download site is here - I recommend the "Minimal ISO" for servers:

https://www.centos.org/download/

Then you need to turn that into installable media. The easiest way to do that these days is a "live USB". Fortunately, CentOS have provided an excellent HOWTO for that step already, and there is no sense in me repeating myself, so if you need to make a live USB, go and read this:

https://wiki.centos.org/HowTos/InstallFromUSBkey

Once you have a live USB, you can restart the target computer and (this obviously varies from computer to computer) interrupt the boot sequence and boot from the USB stick. Follow the install wizard and install CentOS. Once again, someone has done the hard work for me here, so no sense in writing all that again! Here's a nice run-through, with pictures, of the CentOS 7 installer:

https://www.howtoforge.com/tutorial/centos-7-minimal-server/

If you are in a corporate environment, and you don't appear to be able to get Internet access post-installation, you may need to use a proxy server. You should be able to ask your local desktop support staff about this, if you do, here is a good article about how to set that up with some pretty straightforward terminal commands:

http://www.thesysadminhimself.com/2013/08/configuring-web-proxy-on-cento...

OK, so we have CentOS, we have an Internet connection. Before we go on, let's just look at the basics of running commands as the root user. If you're not root, you can wrap any terminal commands in this:

su -c "my command here"

Note, it will ask you for the root user password, not your user's password. Or you can simply become the root user like this:

su root

Again, it's the root user password you'll be asked to give. I will assume you're operating as a normal user and using su -c with my examples, as that's consistent with the way RHEL does things, but if you switch to root then the su -c stuff is not necessary.

Next job is to update the system, just to make sure we have the latest of everything:

su -c "yum update -y"

Now, to avoid what scar-riddled Linux veterans call "dependency hell", you'll want to install a package called "yum-priorities". It isn't installed as standard, because some CentOS heavy hitters believe it's a bad idea, due to the restrictions it places on package availability. But I can tell you from bitter experience, it's vital protection for the beginner. In my early RHEL days I've had to start over after installing my way into a hole without yum-priorities!

It allows you to tell the package manager which repositories are more important, thus avoiding a situation where the package manager tries to install different packages from different repositories which depend on different versions of the same sub-packages. Essentially, if you don't give you package manager some sense of priority over software sources it becomes a free-for-all, it installs packages to achieve one purpose that then block you from doing something else, and the whole thing becomes a bowl of Linux package spaghetti. So, trust me:

su -c "yum install yum-priorities -y"

We'll come back to that in a moment. Now we'll install some extra repositories. The core RHEL / CentOS repositories are pretty slim. They lack a lot of useful software and they also hold quite old versions of other software you need, so you'll want to gain access to a wider set of packages and a more up to date source. The most common and trusted source for this is a repository called EPEL, which is managed by the Fedora Project, which is kind of RHEL's open source testing branch. (It's also my desktop of choice for some years.) Rackspace have written a good HOWTO on installing EPEL and other useful repositories:

https://support.rackspace.com/how-to/install-epel-and-additional-reposit...

For Drupal 7 you probably only need EPEL. For Drupal 8, you'll want the Remi repository too, because Remi provides latest PHP, whereas EPEL is sporting (a security patched and supported version of) PHP 5.4 (at time of writing). In any case, follow the above HOWTO as far as you need to.

Now you have all your repositories in place, you can configure yum-priorities. Again, someone else has written good instructions for this, so rather than re-write them, here's a link:

https://wiki.centos.org/PackageManagement/Yum/Priorities

We're almost there now!

su -c "yum install php httpd mysql -y"

That will go off and fetch all the bits Drupal needs in order to function. You're so close now, you can smell it! Just one last HOWTO to go through: The actual installation of Drupal itself, which again, someone else has thoughtfully documented for us:

https://www.howtoforge.com/centos-7-drupal-installation

One extra thing. For bonus points, install memcached and the memcache module for Drupal, to use this simple cache store for Drupal's caching instead of the database, and improve the performance of your Drupal website significantly. 

su -c "yum install memcached -y"

All you need to do then is follow the README file. And that's it! Happy Drupalling!

 

Blog#AberdeenCloud FAQ Case studyDesign-led Drupal for a local authority Blog#AberdeenCloud - what happened? BlogDoing more with Drush sql-sanitize
Categories: Drupal

InternetDevels: Drupal website security: the main things to know

Drupal Planet - Tue, 2016-07-12 06:24

After the blog posts about Drupal’s benefits for
university websites and ecommerce websites,
we would like to discuss Drupal security. Let’s start!

Read more
Categories: Drupal

ThinkShout: The Hidden Power of Documentation

Drupal Planet - Tue, 2016-07-12 05:00

Anyone who works on team-based projects knows how handy good project documentation is, and how frustrating it can be when that documentation is out of date, incomplete, or just not there. But there are other benefits to good documentation aside from convenience, and a solid system for writing and maintaining documentation is the key.

Defining Documentation

Before we begin, we should be clear about what we mean when we say ‘Project Documentation’ (Docs for short). We’re referring to the information for team members (developers, designers, project managers, and engineers) who join a project at some point after initial development has begun, or even long after a project is complete, such as a maintenance team. This is different than User/Tech docs (how things work on a site), and Code docs (Comments, README files, etc.).

Good docs allow these team members to get up to speed on a project with a minimum of questions for existing or previous team members. In an ideal world, docs alone would suffice in getting someone set up and working on new features, bugfixes, or other project tasks.

Additional Benefits

The convenience of good docs is apparent to anyone who joins a project after it has begun, but consider some of the other benefits:

  • Junior developers will be able to reference docs, instilling confidence.
  • A team member leaving your company will not cause as much of a ‘knowledge drain’.
  • Consistent docs allow any team member to quickly jump in and out of projects as needed, providing project managers with additional flexibility in resource allocation.
  • Long-dormant projects can be resurrected quickly, even if none of the original team members are available.
  • Figuring out where a project’s code is, how to install it locally, how to make/commit changes to production, and tracking down the original wireframes, designs, and planning docs can take days if the original team members are not available. Good docs can cut this time to under an hour, or even minutes in some cases.
  • Docs that accompany open-source projects are especially useful in saving the end-user AND the maintainer’s time.
Location, Location, Location

Having your docs in one place, or in the same place on every project is the first step in making them easy to find - after all, what good are the docs if nobody can find them? ThinkShout uses GitHub for all of its projects, so we take advantage of the fact that every project on GitHub has a free Wiki. A link in the README.md to the wiki means everyone can find the docs in seconds.

A Solid Foundation

The keys to good docs are consistency, accuracy, and completeness:

Consistency

For our Wiki, we have a template we use for every project’s docs, so we don’t have to search for the information among 40 different documentation styles. Your project’s needs may differ, but this should be a good starting point (this is in Markdown):

## Current Status (Site Type / Status. Drupal, WordPress, under development, maintenance, etc...) ## Site Build Info * [Wireframes](URL) * [Budget](URL) * [Implementation overview](URL) * [Migration Spreadsheet](URL) * [Style Guide](URL) ## Build Team * Name (Team Lead) * Name (Back-end) * Name (Front-end) * Name (PM) * Name (Design/UX) ## Hosting * [Dev](URL) * [Test](URL) * [Live](URL) ## Issue Tracking [Redbooth Tasks](URL) ## Deploying Code Note: it is a good practice to run backups before deploying. `cd ~/projects/PROJECTAME;git pull;./scripts/deploy.sh` ## Installation Notes Clone into `projects` folder, install to `~/Sites/`: cd ~/projects git clone git@github.com:thinkshout/PROJECTNAME.git cd PROJECTNAME composer update ./scripts/build.sh ~/Sites/PROJECTNAME root root PROJECTNAME Download db and files from [production](production backup URL) Install the db by opening Sequel Pro, deleting the PROJECTNAME db, adding a new PROJECTNAME db, and importing the live db, then truncating all of the cache_* tables. Install the files by unzipping the file download and copying them to `~/Sites/PROJECTNAME/sites/default/files`, then run: chmod -R 777 ~/Sites/PROJECTNAME/sites/default/files drush cc all drush fra -y Log in: drush uli Disable cache and JS/CSS file aggregation at http://PROJECTNAME.dev/admin/config/development/performance ## Front-end Setup Theme directory is at: `~/Sites/PROJECTNAME/profiles/PROJECTNAME/themes/custom/PROJECTNAME` To get Sass running, `cd` to that directory and run `bundle` Thereafter, you only need to run `rake serve` from the theme directory. Accuracy

The nice thing about having your docs in a wiki is that everyone in your organization can edit them if they discover they are out of date. When a new team member is added to a project, encourage them to work from the docs and see how far they can get without asking for clarification or dealing with an unexpected error. And make sure they update the docs to reflect their experience - the only time docs are ‘done’ is when anyone can use them reliably every time. If you have to ask what something means, it’s likely that the next person will need to know that too - so update the docs!

Completeness

Every project has its quirks and exceptions to the standard procedures - usually for good reason. Good docs will not only note exceptions to standard procedures, but also explain why. In addition, sometimes a ‘Phase 2’ project will require additional information. Make note of these major updates with details such as planning info, principals, dates, and an overview of what was accomplished.

Sometimes a developer will run across coding environment issues that hold them up - this is quite common for the complex front-end setups needed to compile SASS into CSS. Front-end developers sometimes take these setups for granted, but documenting that install process can mean that your back-end developer can handle small CSS changes without assistance:

To get Sass running, `cd` to that directory and run `bundle` Thereafter, you only need to run `rake serve` from the theme directory. NOTE: If you get a 'not found' error after running `bundle`, run `gem install bundler`, then `bundle install`. Part of Your Process

Finally, it’s not enough to have all of these wonderful docs in place and forgotten - they have to be a part of your project setup and launch checklist, and it needs to a part of every project, big or small.

Consistent, accurate, and complete project documentation will save time, make your code easier to maintain, improve team confidence, and do a great service to every developer who comes to your project after it’s finished. Docs Rocks!

Categories: Drupal

Flickr: Hypori - Website Built With Drupal

Drupal Talk - Tue, 2016-07-12 02:21

RootInfoSol posted a photo:

We developed this for an IT company (Hypori) that is very much like us dealing into the mobility solutions for different business verticals from healthcare and finance to retail, enterprise and federal.

Platform: Drupal

For Drupal Web Development Services, visit :- rootinfosol.com/service/drupal-web-development

Categories: Drupal

TimOnWeb.com: Happy birthday to me and Devel form debug module to you all

Drupal Planet - Tue, 2016-07-12 01:36
I’m turning 32 today. People love birthdays, to me it’s just another line number in a messed stack trace output (philosophy mode enabled).   Two years ago I released a drupal module called Get form id (deprecated from now on) that does one small task - it tells you any form's id ...

Read now

Categories: Drupal

Matt Glaman: Explore Drupal Commerce 2 with Commerce Demo!

Drupal Planet - Mon, 2016-07-11 17:08

When we talk about , the biggest we questions we get are not about features, but when you can start building with it. Well, the answer is and has been now! Drupal Commerce 2 has been in alpha . What does this mean? In alpha we might have some schema changes, requiring a reinstall of your site. Luckily Drupal 8 has that fancy new configuration management system to export your site, right?

But what about products! That's data you lose on each reinstall. Luckily, we have in core and has been kicked off for Drupal 8. Generally speaking, most e-commerce sites have some sort of CSV or other file format containing product information. You can use Migrate to import that data and begin building your Drupal Commerce 2 site.

Imperceivable?! Nay! See the . This provides a T-Shirt product type with some and color attributes. It also imports sample products from a CSV. The CSV mimics the flat format you might receive from am ERP, you hopefully you can re-use it!

Here's how you can add it to your Drupal site using composer.

"repositories": [ { "type": "vcs", "url": "https://github.com/mglaman/commerce_demo" } ],

Otherwise, download it from GitHub: https://github.com/mglaman/commerce_demo/archive/master.zip

What's next? This module will showcase the new flexibility and control you have over your Drupal Commerce site, with best practices in mind.

Categories: Drupal

DrupalCon News: Get involved in the DrupalCon Photography Team

Drupal Planet - Mon, 2016-07-11 14:04

DrupalCon has a lot going on at all times — sessions, BoFs, summits, hallway track conversations, social events, exhibitor fun, and more.  We're putting together a photography team to help capture these awesome moments, and want YOU to help us out!  

Categories: Drupal

Drupal @ Penn State: Drupal + xAPI + H5P to track user feedback

Drupal Planet - Mon, 2016-07-11 13:26

I got a question in from twitter asking if we had a video showing what we were doing with Drupal, xAPI and H5P. I said sure! And I hurried off across youtube and my many blogs to find it. Just… gotta… find… that… post.. I mean, I know I did it I HAVE TO HAVE DONE IT ITS SO DAMN COOL.

Categories: Drupal

Drupal @ Penn State: The low-down on DrupalcampPA July 30/31 in Pittsburgh!

Drupal Planet - Mon, 2016-07-11 13:26

DrupalcampPA is July 30 and 31st in Pittsburgh PA and Yinz-all should come! We just announced our full schedule with keynotes, giveaways, and more. Some quick highlights of why you should come! Submissions this year tried to take the stance of “getting off the island” by having more and more presentations about topics that plug into or are affiliated with Drupal without just being about Drupal.

Categories: Drupal

Daniel Pocock: Let's Encrypt torpedoes cost and maintenance issues for Free RTC

Drupal Planet - Mon, 2016-07-11 06:34

Many people have now heard of the EFF-backed free certificate authority Let's Encrypt. Not only is it free of charge, it has also introduced a fully automated mechanism for certificate renewals, eliminating a tedious chore that has imposed upon busy sysadmins everywhere for many years.

These two benefits - elimination of cost and elimination of annual maintenance effort - imply that server operators can now deploy certificates for far more services than they would have previously.

The TLS chapter of the RTC Quick Start Guide has been updated with details about Let's Encrypt so anybody installing SIP or XMPP can use Let's Encrypt from the outset.

For example, somebody hosting basic Drupal or Wordpress sites for family, friends and small community organizations can now offer them all full HTTPS encryption, WebRTC, SIP and XMPP without having to explain annual renewal fees or worry about losing time in their evenings and weekends renewing certificates manually.

Even people who were willing to pay for a single certificate for their main web site may have snubbed their nose at the expense and ongoing effort of having certificates for their SMTP mail server, IMAP server, VPN gateway, SIP proxy, XMPP server, WebSocket and TURN servers too. Now they can all have certificates.

Early efforts at SIP were doomed without encryption

In the early days, SIP messages would be transported across the public Internet in UDP datagrams without any encryption. SIP itself wasn't originally designed for NAT and a variety of home routers were created with "NAT helper" algorithms that would detect and modify SIP packets to try and work through NAT. Sadly, in many cases these attempts to help actually clash with each other and lead to further instability. Conversely, many rogue ISPs could easily detect and punish VoIP users by blocking their calls or even cutting their DSL line. Operating SIP over TLS, usually on the HTTPS port (TCP port 443) has been an effective way to quash all of these different issues.

While the example of SIP is one of the most extreme, it helps demonstrate the benefits of making encryption universal to ensure stability and cut out the "man-in-the-middle", regardless of whether he is trying to help or hinder the end user.

Is one certificate enough?

Modern SIP, XMPP and WebRTC require additional services, TURN servers and WebSocket servers. If they are all operated on port 443 then it is necessary to use different hostnames for each of them (e.g. turn.example.org and ws.example.org. Each different hostname requires a certificate. Let's Encrypt can provide those additional certificates too, without additional cost or effort.

The future with Let's Encrypt

The initial version of the Let's Encrypt client, certbot, fully automates the workflow for people using popular web servers such as Apache and nginx. The manual or certonly modes can be used for other services but hopefully certbot will evolve to integrate with many other popular applications too.

Currently, Let's Encrypt only issues certificates to servers running on TCP port 443. This is considered to be a privileged port whereas any port over 1023, including the default ports used by applications such as SIP (5061), XMPP (5222, 5269) and TURN (5349), are not privileged ports. As long as Let's Encrypt maintains this policy, it is necessary to either run a web server for the domain associated with each certificate or run the services themselves on port 443. Running the services themselves on port 443 turns out to be a good idea anyway as it ensures that RTC services can be reached through HTTP proxy servers who fail to let the HTTP CONNECT method access any other ports.

Many configuration tasks are already scripted during the installation of packages on a GNU/Linux distribution (such as Debian or Fedora) or when setting up services using cloud images (for example, in Docker or OpenStack). Due to the heavily standardized nature of Let's Encrypt and the widespread availability of the tools, many of these package installation scripts can be easily adapted to find or create Let's Encrypt certificates on the target system, ensuring every service is running with TLS protection from the minute it goes live.

If you have questions about Let's Encrypt for RTC or want to share your experiences, please come and discuss it on the Free-RTC mailing list.

Categories: Drupal

DrupalEasy: Best Practices = Effective Government

Drupal Planet - Mon, 2016-07-11 05:52

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

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

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

Carla Stoner

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

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

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

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

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

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

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

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

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

Categories: Drupal

Appnovation Technologies: Selling the Drupal Community to Those Here for the Code

Drupal Planet - Mon, 2016-07-11 05:15

Throughout the software development world there are many “evangelist” roles who sell the code to the community, but maybe we need the other side? Maybe we need to sell the community to the those who are just there for the code.

Categories: Drupal

Mediacurrent: Brain Food for Your Post-DrupalCon Slump

Drupal Planet - Mon, 2016-07-11 05:10

DrupalCon always provides many opportunities to discover new methods and tools, and this year’s conference in New Orleans was no different.

Categories: Drupal

Liip: An opensource Drupal theme for the Swiss Confederation

Drupal Planet - Mon, 2016-07-11 05:08

After having contributed to the official styleguide of the Swiss Federal Government and having implemented it on a couple of websites, we decided to go further and bring these styleguide into a theme for Drupal, a well-known, pluripotent and robust CMS we implement regularly at Liip.

The current result is a starterkit providing the essential bricks to start in a snap a website project for the federal government running with Drupal 8, based on the version 3 of the official styleguide.

Navigation modules, multilingual environnement per default (German, French, Italian, Rumantch and English), responsive layout following the Web Content Accessibility Guidelines, we threw the fundamental stones for bootstraping a web platform for the Confederation.

con~foederatio : to build a league, together.

In other words, joining forces, to support a common cause. From the very start of the project we decided to opensource the code, as a participatory initiative.
Learn more about this intent (German only).

Any developer working on a new website for the swiss government can now quickly start developing with this Drupal starterkit, then modify, contribute and improve it collegially. Pulling requests and opening issues on GitHub is the recommended way to help us extend further the project.

What’s inside the box

The Bund-Starterkit provides theme and elements based on the official styleguide (version 3.0.0) of the Swiss Federal Administration.

This starterkit also contains a base to quickly implement a website running on Drupal 8 for the Swiss Federal Administration. Currently, it provides the following Drupal and frontend elements:

  • Multilingual main navigation blocks
  • Multilingual service navigation blocks
  • Multilingual footer service navigation blocks
  • Logo block
  • Language switcher block with German, French, Italian, Rumantsch enabled
  • All the assets (CSS, SASS. JS files) provided by the official styleguide
  • A ready-to-use SASS workflow
Installation process, an overview

Please check the Readme file to quickly start your project. But let’s have a look at the details of the installation process. First of all, Composer (a PHP dependencies manager) is binding together for us the following repositories:

After downloading the sources with Composer and setting your vhost and hosts files, you have two options. Continuing with a few drush commands to run the Drupal installation process, or following the installation wizard in the browser. If you choose this last option, don’t forget to select the «Bund profile» option when the wizard ask you to choose a profile:

Continue with the last steps of the wizard and that’s it. you should be able to see an empty Drupal 8 website, painted with the swiss administration’s corporate sauce.

Inserting menus content

With the help of a .CSV file and some drush commands, you can quickly import your menu structure. Once done, create and assign your content the the freshly created menu items through the Drupal administration interface.

Theming

Don’t forget to create a personal Drupal sub-theme from the bund_drupal_starterkit_theme, as a Drupal best practice.  Don’t edit the existing theme directly or you could loose your changes after a future update.

Frontend

This starterkit use the official styleguide (version 3.0.0) as a submodule. All existing CSS/JS files and assets are imported and available per default, but not necessary integrated as a drupal module at the moment. We highly encourage you to check the official styleguide before adding any new CSS style or JS files to your project. Based on the existing styles, it should be possible to create a lot of Drupal templates without modifying or extending any CSS. And as already said, we invite you to share any Drupal template matching the styleguide you would develop for your project.

Further reading
Categories: Drupal

Tim Millwood: Selling the Drupal community to those here for the code

Drupal Planet - Mon, 2016-07-11 05:03
Throughout the software development world there are many “evangelist” roles who sell the code to the...
Categories: Drupal

OpenLucius: Update OpenLucius | June 2016

Drupal Planet - Mon, 2016-07-11 01:28

We just updated OpenLucius, these are the most important changes:

Categories: Drupal

PreviousNext: Refactoring Drupal batch API callbacks to increase testability

Drupal Planet - Sun, 2016-07-10 23:44

Drupal's Batch API is great, it allows you to easily perform long running processes with feedback to the user.

But during Drupal 8's development processes it was one of the remaining systems that didn't get the full object oriented, service-based architecture.

Much of the batch API is largely unchanged from Drupal 7.

But that doesn't mean you can't write unit-testable callbacks.

Let's get started.

Categories: Drupal
Syndicate content

Powered By