Planet Drupal

Subscribe to flux Planet Drupal
Drupal.org - aggregated feeds in category Planet Drupal
Mis à jour : il y a 47 min 37 sec

ImageX Media: Insights from a Web Redesign that Transformed our Online Presence

mar, 12/07/2016 - 22:36

One of the greatest benefits of working in our field is the opportunity to connect with industry leaders who we might not have crossed paths with otherwise. Our clients span the gamut -- from higher education, to technology and beyond -- and Noe Marti from Verimatrix is one of those leaders. Noe was kind enough to contribute to our blog, sharing some of the insights that Verimatrix learned from a recent website redesign that they partnered with ImageX on -- and that ultimately transformed their online presence entirely.

Catégories: Elsewhere

Aten Design Group: Drupal's Weak Link

mar, 12/07/2016 - 22:16

One of the things I love about Drupal is the entity reference field. In Drupal 8, entity reference fields are even better because they’re now included in Drupal Core. This makes building composed and well-structured data is much easier. However, I think as Drupal developers and architects, we’re fundamentally misusing them in far too many cases. Over and over, we use entity references to denote a relationship between two entities instead of a simple reference or inclusion. Mere entity references severely limit our ability to create rich, rational content type architectures and force us to jump through additional hoops and write more custom code than ought to be required. I believe that Drupal having only entity references to forge relationships between content types is a major shortcoming.

What We’ve Got

Before we can understand what Drupal is missing, we first need to know what we already have. Out of the box, we can create different types of data. These are our Content Types. Different types of data might be people, blog posts or schools. If you can give it a name and describe it, there’s probably a way to represent it as an entity in Drupal. These data types can reference one another using entity references – a blog post might reference its author or a school might have a reference to all of its students. When we create the reference, we’re drawing a little imaginary arrow that points from a blog post to user entity.

Let’s explore this concept through a scenario. You’ve been tasked with building a club management system. It should be able to represent a lots of different clubs. The Engineering Club and the Theater Club, for example. We know that every club can have members and those members are the users of our application.

How should we manage memberships? Currently, we would model the relationship between clubs and members with an entity reference. Users might have an entity reference field that references the clubs to which they belong or club nodes might have a field holding all the users that are part of its membership.

What We’re Missing

So, what’s wrong with that? Problems start to creep up as you start building out the rest of the application. Let’s add a some new requirements. Some clubs need to represent who their Chair and Co-Chair is on their club homepage. Another club needs to have a treasurer. Another club just arbitrarily gives away titles to their members like, “Director of Pizza Ordering”

WIth entity references alone, we’d be hard pressed to model all of this. We might try to create a “President” or “Treasurer” field on the club content type, but that wouldn’t solve our arbitrary title requirement. We could but a text field on the user for their title, but permissions would get weird and it wouldn’t work for members of more than one club.

The truth is that the reference model doesn't work. Relationships aren’t just little arrow from A→B like an entity reference implies. Relationships aren’t always going in just one direction either, sometimes a relationship can both ways, like a friendship. The technical term for this is ‘directed’ and ‘undirected’. Entity references only ever go one direction.

At the end of the day, relationships between data types are complex and varied. It’s important to be able to describe the nature of a relationship between things in Drupal, be it duration, kind or direction. Clubs can have different kinds of members. Flights can have first class and economy passengers. Friends can be best friends. A celebrity might have followers, but that doesn’t mean that the celebrity is following all of their fans. All of these relationships aren’t easy to model in Drupal. Entity references are a blunt tool for an intricate world.

A Stronger Link

The correct approach to our club management problem is to model relationships as entities themselves. In the club management application, what we really needed was a ‘membership’ entity. That ‘membership’ type, would store a reference to the club and to the user, linking them together. But because this ‘membership’ type would be a fieldable entity, it would be trivial to create a taxonomy of membership types. We could just have an autocomplete taxonomy term field for terms like “President”, “Treasurer” or even “Director of Pizza Ordering.”

The idea is really that simple. Yet, time and time again, I see Drupal sites relying solely on an entity reference when there’s clearly a relationship involved. Entity references should only be used where the referenced content is truly part of the thing from which it’s being referenced. Media entities and taxonomy terms are perfect use cases for an entity reference. As we’ve seen though, entity references aren’t the right tool for everything. To spot relationships vs. references, ask yourself, “is this thing really part of this content? Is there a verb between my content?” Like, “A user joins a club.”

What’s Stopping Us?

In many ways, we already have all the tools we need to build our sites and applications with these concepts. It’s entirely possible for you to create entities representing relationships now. Nothing is stopping you from creating a membership node or a more custom entity using something like Entity Construction Kit.

If the answer to these issues is so simple. Why don’t we always use this strategy? Why do we as Drupal developers instinctively reach for the entity reference when we clearly want entity relationships?

The reality is that it’s more work up front. You have to worry about more content types. You need to theme more things. When creating a user, it’s not just as easy as checking all the clubs they belong to on their edit form. It’s a two-step process. When a user is deleted, we have to automatically know to delete their memberships. Frankly, it’s just more work.

The Fix

Most, if not all, of the problems with relationship types can be solved with no knowledge of the kinds of relationships involved. For example, automatically deleting a relationship with one of the entities on it is removed could be a pretty universal rule that could be easily overridden when needed.

That’s why I think imagining Drupal with a core Relationship type is an enticing idea. There’s already precedent for creating new entity types to better model content. That’s exactly what taxonomy terms are. They’re an entity type separate from a node that have some extra features like hierarchy and autocomplete/creation. Taxonomy terms are a fantastic tool in our toolbox. Sure, we might have to educate new site builders and clients about them, but once the concept is conveyed, people really run with the idea.

There are solutions out there that attempt to address these problems of relating entities today, but none are fully satisfying. There are plenty of modules that create bidirectional entity or node references, but they fall short because they are not fieldable. Foremost among these solutions is the Relation module. I really liked this module in D7, in fact, I built a few modules around it. Unfortunately though, it does not have a shippable release for Drupal 8 and it’s billed purely as an API module for developers. There’s not much of a user interface either. *

Relationships, I think, are the next logical progression in Drupal’s content architecture model. Having true relationships would enable us to do all kinds of neat things and make so much custom code completely unnecessary. Just imagine the simple idea of a publishing company where a manager should be able to edit any of the content of their subordinates. You might be able to write some custom code, but with Relationships, we could write simple modules that rely on the relationship abstraction to configure access policies, not write them custom code.

I’m working on a module to explore these ideas and uncover roadblocks, but I really would love to get the community’s response. If you found this post interesting, tell me what you thought made sense and what didn’t. What would you want out of a Relationship type. Maybe you think I’m crazy? All of it will be valuable feedback.

* If you're a maintainer of Relation reading this, thank you! I really do love Relation. It inspired me to think about problems with content modelling in Drupal in this way; I just want to go a heck of a lot further with it!

Catégories: Elsewhere

Palantir: Building Ambitious Projects With Drupal

mar, 12/07/2016 - 21:49
Want to know more about how we make web projects successful? Sign up for our webinar.

Recently, Drupal project lead Dries Buytaert published that Drupal is for ambitious digital experiences. In the post, Dries calls for open discussion of what this term might mean, noting that “Stating that Drupal is for ambitious digital experiences however is only a start. It only gives a taste of Drupal's objectives, scope, target audience and advantages.”

At Palantir, we’ve been working with Drupal for over ten years now. From our perspective as a Drupal-focused team, the term resonates. A quick review of some of our Drupal projects shows what we mean when we talk about ambition.

  • Foreign Affairs
    Innovative interactions with decades of foreign policy expertise, with deep, contextual links to related content.
  • University of Minnesota
    A scalable, replicable site building tool that powers thousands of websites on a common platform.
  • Streaming Video API
    An editorial platform and API service for building on-demand streaming video services.
  • Long Term Ecological Research Network
    A Drupal distribution that allows environmental scientists around the world to publish, share, and discover terabytes of historical climate data.
  • The King Center
    An interactive archive of the complete letters and papers of one of the 20th century’s most important figures, Dr. Martin Luther King, Jr.

On a personal note, I developed the first version of Domain Access back in 2005-2006 as part of an ambitious project. The magazine company I was working with asked “would it be possible to spin up new sites, complete with content and custom design, within minutes instead of weeks?” That spirit of exploration and discovery fires the work we do with Drupal.

It’s that ability to do rapid iteration on new ideas -- an idea that is central to the open source movement that Drupal is part of -- that powers innovation and keeps us motivated. It’s why we’re working now on the Drupal 8 port of that module.

But that innovation isn’t just technical. The idea of ambition maps very closely to one of the activities we do during client kickoff meetings. We like to ask our clients what they Like, Wish, and Wonder about their digital marketing. It’s that final question about wonder that uncovers project ambitions and opens up new possibilities. As an open platform, Drupal excels in making those ambitions possible.

And it’s the wonder of possibility that I think is captured in Dries’ use of the term ambitious.

We want to make your ambitious project a success. Let's schedule a time to talk.
Catégories: Elsewhere

James Oakley: Be Prepared for Drupal Contrib Security Updates

mar, 12/07/2016 - 20:33

The Drupal Security team has just released a public security announcement, PSA 2016-001.

There will be multiple releases of Drupal contributed modules on Wednesday July 13th 2016 16:00 UTC that will fix highly critical remote code execution vulnerabilities (risk scores up to 22/25).

If you run any Drupal sites, please be prepared, and be ready to update your site as soon as this is released.

Blog Category: Drupal Planet
Catégories: Elsewhere

Cheeky Monkey Media: Building a Custom Module - Part 3

mar, 12/07/2016 - 20:06
Building a Custom Module - Part 3 yan Tue, 07/12/2016 - 18:06

This is part 3, of a 3 part tutorial for creating a custom module for drupal 7. If you haven't already done so, you may wish to look at part 1 and part 2 first. Anyway, here is the source code of this tutorial.

First of all, though, I have to apologize that I did not do a good job of keeping track of all of the changes made so far. I code everything before I start writing, so hopefully it is not too confusing.

There are few things I would like update this time so here is a list of the things that I want to cover in this tutorial:

Catégories: Elsewhere

Chromatic: Code Standards: How Do We Implement Them?

mar, 12/07/2016 - 18: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

Catégories: Elsewhere

Chromatic: Civil Comments Drupal Module

mar, 12/07/2016 - 18: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!

Catégories: Elsewhere

Code Enigma: Spinning up a CentOS server for Drupal

mar, 12/07/2016 - 17: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
Catégories: Elsewhere

InternetDevels: Drupal website security: the main things to know

mar, 12/07/2016 - 15: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
Catégories: Elsewhere

ThinkShout: The Hidden Power of Documentation

mar, 12/07/2016 - 14: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!

Catégories: Elsewhere

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

mar, 12/07/2016 - 10: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

Catégories: Elsewhere

Matt Glaman: Explore Drupal Commerce 2 with Commerce Demo!

mar, 12/07/2016 - 02: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.

Catégories: Elsewhere

DrupalCon News: Get involved in the DrupalCon Photography Team

lun, 11/07/2016 - 23: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!  

Catégories: Elsewhere

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

lun, 11/07/2016 - 22: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.

Catégories: Elsewhere

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

lun, 11/07/2016 - 22: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.

Catégories: Elsewhere

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

lun, 11/07/2016 - 15: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.

Catégories: Elsewhere

DrupalEasy: Best Practices = Effective Government

lun, 11/07/2016 - 14: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. 

Catégories: Elsewhere

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

lun, 11/07/2016 - 14: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.

Catégories: Elsewhere

Mediacurrent: Brain Food for Your Post-DrupalCon Slump

lun, 11/07/2016 - 14:10

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

Catégories: Elsewhere

Pages