5-Day Drupal 8 Training Washington DC

2019-02-25 09:00 - 2019-03-01 16:30 America/New_York




Event type: 

Training (free or commercial)


Learn how to build a website with Drupal from top to bottom. This is a week-long Drupal class divided into three parts: site building, theming, and module development. You can register for all five days, or for each part individually, depending on your learning needs.
Day 1: Drupal 8 Site Building
The Drupal content management system is known for its flexibility. Drupal can be used for many types of websites, from media portals to e-commerce sites, to community forums. Site builders have the task of customizing Drupal depending on the content and feature-set they want to provide. This section of the course will give participants a thorough understanding of the Drupal site building process. You'll get hands-on experience implementing advanced features with Drupal core and contributed modules. Understanding of basic Drupal concepts (or having taken an introduction to Drupal course) is required.
Days 2-3: Drupal 8 Theming
Learn techniques for customizing the look of a Drupal site by creating a custom theme. This section of the course will cover Twig templating, creating layouts, and best practices for organizing your theme. We'll also cover responsive techniques and sub-theming. Familiarity with HTML and CSS is required.
Days 4-5: Drupal 8 Module Development
While Drupal 8 core and contributed modules provide a lot of powerful features, you might have some situations where you need to develop custom functionality for your website. In this section of the course, you'll learn how to create Drupal 8 modules from scratch. Some programming background required.
For a full course outline, see the training description on our website.
Location: Downtown Washington (Exact Location TBD)
Registration: https://evolvingweb.ca/training/5-day-drupal-8-training or https://www.eventbrite.ca/e/5-day-drupal-8-training-in-washington-dc-tic...
What's provided? Lunch, snacks, and a training manual. Lots of one-on-one help as you go through the course.
Should I bring a laptop? Yes, please bring a laptop for the course.
Can I pay with a cheque? Yes, contact us and we can issue you an invoice for the training.
What are the pre-requisites? Understanding of basic Drupal concepts for Day 1, Familiarity with HTML and CSS required for Days 2-3, Programming experience required for Days 4-5
Do you offer discounts? Yes, we provide discounts for students, freelancers, and non-profit organizations. Please contact us for details.
Source: https://groups.drupal.org/node/512931/feed

Plan for Drupal 9

At Drupal Europe, I announced that Drupal 9 will be released in 2020. Although I explained why we plan to release in 2020, I wasn't very specific about when we plan to release Drupal 9 in 2020. Given that 2020 is less than thirteen months away (gasp!), it's time to be more specific.

Shifting Drupal's six month release cycle

We shifted Drupal 8's minor release windows so we can adopt Symfony's releases faster.
Before I talk about the Drupal 9 release date, I want to explain another change we made, which has a minor impact on the Drupal 9 release date.

As announced over two years ago, Drupal 8 adopted a 6-month release cycle (two releases a year). Symfony, a PHP framework which Drupal depends on, uses a similar release schedule. Unfortunately the timing of Drupal's releases has historically occurred 1-2 months before Symfony's releases, which forces us to wait six months to adopt the latest Symfony release. To be able to adopt the latest Symfony releases faster, we are moving Drupal's minor releases to June and December. This will allow us to adopt the latest Symfony releases within one month. For example, Drupal 8.8.0 is now scheduled for December 2019.

We hope to release Drupal 9 on June 3, 2020

Drupal 8's biggest dependency is Symfony 3, which has an end-of-life date in November 2021. This means that after November 2021, security bugs in Symfony 3 will not get fixed. Therefore, we have to end-of-life Drupal 8 no later than November 2021. Or put differently, by November 2021, everyone should be on Drupal 9.

Working backwards from November 2021, we'd like to give site owners at least one year to upgrade from Drupal 8 to Drupal 9. While we could release Drupal 9 in December 2020, we decided it was better to try to release Drupal 9 on June 3, 2020. This gives site owners 18 months to upgrade. Plus, it also gives the Drupal core contributors an extra buffer in case we can't finish Drupal 9 in time for a summer release.

Planned Drupal 8 and 9 minor release dates.We are building Drupal 9 in Drupal 8

Instead of working on Drupal 9 in a separate codebase, we are building Drupal 9 in Drupal 8. This means that we are adding new functionality as backwards-compatible code and experimental features. Once the code becomes stable, we deprecate any old functionality.

Let's look at an example. As mentioned, Drupal 8 currently depends on Symfony 3. Our plan is to release Drupal 9 with Symfony 4 or 5. Symfony 5's release is less than one year away, while Symfony 4 was released a year ago. Ideally Drupal 9 would ship with Symfony 5, both for the latest Symfony improvements and for longer support. However, Symfony 5 hasn't been released yet, so we don't know the scope of its changes, and we will have limited time to try to adopt it before Symfony 3's end-of-life.

We are currently working on making it possible to run Drupal 8 with Symfony 4 (without requiring it). Supporting Symfony 4 is a valuable stepping stone to Symfony 5 as it brings new capabilities for sites that choose to use it, and it eases the amount of Symfony 5 upgrade work to do for Drupal core developers. In the end, our goal is for Drupal 8 to work with Symfony 3, 4 or 5 so we can identify and fix any issues before we start requiring Symfony 4 or 5 in Drupal 9.

Another example is our support for reusable media. Drupal 8.0.0 launched without a media library. We are currently working on adding a media library to Drupal 8 so content authors can select pre-existing media from a library and easily embed them in their posts. Once the media library becomes stable, we can deprecate the use of the old file upload functionality and make the new media library the default experience.

The upgrade to Drupal 9 will be easy

Because we are building Drupal 9 in Drupal 8, the technology in Drupal 9 will have been battle-tested in Drupal 8.

For Drupal core contributors, this means that we have a limited set of tasks to do in Drupal 9 itself before we can release it. Releasing Drupal 9 will only depend on removing deprecated functionality and upgrading Drupal's dependencies, such as Symfony. This will make the release timing more predictable and the release quality more robust.

For contributed module authors, it means they already have the new technology at their service, so they can work on Drupal 9 compatibility earlier (e.g. they can start updating their media modules to use the new media library before Drupal 9 is released). Finally, their Drupal 8 know-how will remain highly relevant in Drupal 9, as there will not be a dramatic change in how Drupal is built.

But most importantly, for Drupal site owners, this means that it should be much easier to upgrade to Drupal 9 than it was to upgrade to Drupal 8. Drupal 9 will simply be the last version of Drupal 8, with its deprecations removed. This means we will not introduce new, backwards-compatibility breaking APIs or features in Drupal 9 except for our dependency updates. As long as modules and themes stay up-to-date with the latest Drupal 8 APIs, the upgrade to Drupal 9 should be easy. Therefore, we believe that a 12- to 18-month upgrade period should suffice.

So what is the big deal about Drupal 9, then?

The big deal about Drupal 9 is … that it should not be a big deal. The best way to be ready for Drupal 9 is to keep up with Drupal 8 updates. Make sure you are not using deprecated modules and APIs, and where possible, use the latest versions of dependencies. If you do that, your upgrade experience will be smooth, and that is a big deal for us.

Special thanks to Gábor Hojtsy (Acquia), Angie Byron (Acquia), xjm (Acquia), and catch for their input in this blog post.
Source: Dries Buytaert www.buytaert.net

5-Day Drupal 8 Training - Toronto

2018-10-01 09:00 - 2018-10-05 16:30 America/Toronto



Event type: 

Training (free or commercial)


Learn how to build a website with Drupal from top to bottom. This week-long Drupal class is divided into three parts: site building, theming, and module development. You can register for all five days, or just the days of interest to you.
Day 1: Drupal 8 Site Building & Architecture
This course will give participants a thorough understanding of the Drupal site building process. You'll get hands-on experience creating an information architecture for Drupal, and implementing advanced features with Drupal core and contributed modules.
Planning and implementing content types
Techniques for organizing content with Views
Building layouts with configuration
Structuring content with Paragraphs
Setting up landing pages
Selecting and installing contributed modules
Site maintenance best practices
Pre-launch checklist
Days 2-3: Drupal 8 Theming
You'll learn how to build a responsive Drupal theme to customize the look of your Drupal site. We’ll create a theme based on Drupal core, and another using a front-end framework. Learn how to create layouts, customize Twig templates, and best practices for organizing your theme.
Creating a custom Drupal theme
Using Drupal's core themes
Drupal's templating system
Adding CSS and Javascript to your Drupal theme
Twig syntax and Twig debug
Sub-theming with Bootstrap, Zurb Foundation, etc.
Using Twig to customize Views output
Preprocess functions
Using SASS with your Drupal theme
Extending Twig templates
Using libraries to manage internal and external assets
Best practices for Drupal theming
Days 4-5: Drupal 8 Module Development
You'll learn the process for developing a module with standard components like blocks, permissions, forms, and pages. The course will cover the concepts behind module development, how to use Object Oriented Programming for Drupal 8, and essential Drupal developer tools. It will give you an overall understanding of how modules work and you’ll get hands-on experience developing modules from scratch.
Creating a Drupal 8 module
Drupal coding standards
Using Drush, Drupal Console, and Composer
Creating pages programmatically
Creating custom field types and formatters
Using the Examples module
Creating custom forms
Database integration
Creating blocks programmatically
Creating administrative forms
Creating and applying patches
Configuration management
To register and for details: https://evolvingweb.ca/training/5-day-drupal-8-training
Source: https://groups.drupal.org/node/512931/feed

((FUCK^^TV)) [[LIVE]] !! Man. City vs Liverpool Live Streaming 2018 FREE

Man City vs Liverpool LIVE stream How to watch football online and
express co uk › Sport › Football
3 hours ago MAN CITY VS LIVERPOOL LIVE STREAM How to watch
Link=>> http://hbo420livetv.blogspot.com/2018/07/liverpool-man-city.html
Link=>> http://hbo420livetv.blogspot.com/2018/07/liverpool-man-city.html
International Champions Cup match online and on TV
Manchester City vs Liverpool live stream Watch ICC online TV | SI com
si com manchester city liverpool live stream watch icc online tv chan
3 hours ago How to watch Man City vs Liverpool in the International Champions Cup on Wednesday July 25
Manchester City vs Liverpool Live Stream (Friendly) TOTAL SPORTEK
totalsportek com manchester united live stream
Manchester United tour United States for pre season you can watch free live streaming of all matches with Club America San jose Real Madrid AC Milan
Man City Vs Liverpool Live Stream Watch International Champions
nesn com man city vs liverpool live stream watch international champions
2 hours ago Man City Vs Liverpool Live Stream Watch International Champions Cup Game Online by Marcus Kwesi O'Mard on Wed Jul 25 2018 at 4
Manchester City vs Liverpool live streaming Watch online & prediction
101greatgoals com › Live Streaming
9 hours ago If you want to watch Manchester City vs Liverpool online these are the live streaming instructions Match Manchester City vs Liverpool
Man City vs Liverpool predictions International Champions Cup 2018
standard co uk › Sport › Football
13 hours ago Manchester City vs Liverpool International Champions Cup 2018 prediction tickets betting tips and odds how to watch live stream online
support runkeeper com 360018254331 Watch LIVERPOOL vs MANCHE
59 mins ago 4 hours ago Our guide reveals all you need to know to watch Liverpool vs Man City online and on TV including full live stream details and the
Manchester City Liverpool live score video stream and H2H results
sofascore com liverpool manchester city rU
Manchester City Liverpool live score (and video online live stream) starts on Here on SofaScore livescore you can find all Manchester City vs Liverpool
Manchester City vs Liverpool LIVE score and goal updates from
mirror co uk › Sport › Football › Manchester City FC
35 mins ago Pep Guardiola and Jurgen Klopp lock horns as the countdown continues for the new Premier League season
Notices about Filtered Results
In response to a complaint that
Source: https://groups.drupal.org/node/512931/feed

{LIVE-FREE} - Man. City vs Liverpool Live Streaming% FREE

Manchester City face Liverpool in the second match of their pre-seaosn tour of America
Man City vs Liverpool predictions International Champions Cup 2018
standardcouk › Sport › Football...
Link=>> http://hbo420livetv.blogspot.com/2018/07/liverpool-man-city.html
Link=>> http://hbo420livetv.blogspot.com/2018/07/liverpool-man-city.html
12 hours ago - Manchester City vs Liverpool: International Champions Cup 2018 prediction tickets betting tips and odds how to watch live stream online
Manchester City vs Liverpool live stream: Watch ICC online TV | SIcom
1 hour ago - How to watch Man City vs Liverpool in the International Champions Cup on Wednesday July 25
Manchester City vs Liverpool Live Stream (Friendly) - TOTAL SPORTEK
Manchester United tour United States for pre-season you can watch free live streaming of all matches with Club America San jose Real Madrid AC Milan
Man City Vs Liverpool Live Stream: Watch International Champions
44 mins ago - Liverpool FC now can gauge where it stands against the Premier League elite Manchester City will face Liverpool on Wednesday night at Manchester City vs Liverpool 1-5 - All Goals & Extended Highlights
Video for Manchester City vs Liverpool Live
▶ 11:57
2 hours ago - Uploaded by LIUBCHENKO
10 000 Likes For Manchester City Liverpool & Riyad Mahrez? Manchester City vs Liverpool 1-5 Goles
Man City vs Liverpool: What TV channel live stream kick-off time and
2 days ago - Man City and Liverpool battle it out at the MetLife Stadium in New Jersey in the International Champions Cup
Manchester City vs Liverpool: 2018 ICC Time TV Schedule and Live
2 days ago - Manchester City and Liverpool are each looking to bounce back from defeats to Borussia Dortmund when they clash in the 2018 International
((Online-TV))Liverpool vs Manchester City Live Stream | nalehko
nalehkocom › Forums › obecná diskuse
21 hours ago - Is Liverpool vs Manchester City on TV or can I live stream the match? Man City vs Liverpool Live stream TV channel kickoff time and team
LiVe[WaTcH!@FrEe]~Manchester City vs Liverpool Live Stream
21 hours ago - Manchester City vs Liverpool Live Stream (Friendly) - Total Sportek Watch Live–>> liveonitv247comsoccer Watch
Manchester City Liverpool live score video stream and H2H results
Here on SofaScore livescore you can find all Manchester City vs Liverpool previous results sorted by their H2H matches Links to Manchester City vs Liverpool
Man City vs Liverpool - Preview Live Match | 01 Jan 2019 - Sky Sports
Premier League match Man City vs Liverpool (1 Jan 2019) Preview and stats followed by live commentary video highlights and match report
UEFA Champions League - Man City-Liverpool - UEFAcom
Man City 31 Ederson (GK) Ederson is cautioned by the referee 14'; 2 Walker; 7 Sterling LiveMan City v Liverpool: line-ups Fantasy tips form guide · 00:42
Manchester City vs Liverpool live streaming: Watch online & prediction
101greatgoalscom › Live Streaming
7 hours ago - If you want to watch Manchester City vs Liverpool online these are the live streaming instructions Match: Manchester City vs Liverpool
Champions League Final Stage - Manchester City VS Liverpool - Live
Manchester City 1 - 2 Manchester City Liverpool Champions League Final Stage Etihad Stadium Finished Gabriel Jesus regular-goal 2' 14' yellow-card
Source: https://groups.drupal.org/node/512931/feed


((Online-TV))Liverpool vs Manchester City Live Stream
((Online-TV))Liverpool vs Manchester City Live Stream((Online-TV))Liverpool vs Manchester City Live Stream((Online-TV))Liverpool vs Manchester City Live Stream((Online-TV))Liverpool vs Manchester City Live Stream.Is Liverpool vs Manchester City on TV or can I live stream the match?. Kickoff time, live stream, TV details, odds for Liverpool vs Man City. Man City vs Liverpool Live stream, TV channel, kickoff time and team news
Link=>> http://hbo420livetv.blogspot.com/2018/07/liverpool-man-city.html
Link=>> http://hbo420livetv.blogspot.com/2018/07/liverpool-man-city.html
More for Liverpool vs Manchester City Live Stream. Is Liverpool vs Manchester City on TV or can I live stream the match Liverpool are taking on Pep Guardiola and Manchester City in their second game in the International Champions Cup on Thursday morning
Manchester City vs Liverpool Live Stream (Friendly) Total Sportek
Manchester United tour United States for preseason you can watch free live streaming of all matches with Club America, San jose, Real Madrid, AC Milan
What channel is Liverpool vs Manchester City? Kickoff time, live
smirrorcouk › Sport › Football › Liverpool FC
7 hours ago vs Manchester City? Kickoff time, live stream, TV details, odds and more What time is Manchester City vs Liverpool? Manchester City will
Liverpool FC vs Manchester City Everything you need to know Daily
sdailypostcouk › Sport › Football › Liverpool FC
7 hours ago Liverpool vs Manchester City in the International Champions Cup is being You can also live stream the match via LFC TV Go on your phone,
Man City vs Liverpool What TV channel, live stream, kickoff time and
1 day ago Man City and Liverpool battle it out at the MetLife Stadium in New Jersey in the International Champions Cup
Manchester City vs Liverpool 2018 ICC Time, TV Schedule and Live
18 hours ago Manchester City and Liverpool are each looking to bounce back from defeats to vs Liverpool 2018 ICC Time, TV Schedule and Live Stream
Manchester City vs Liverpool Live Streaming Free Soccer Highlights
Video for Liverpool vs Manchester City Live Stream▶
timesoccercom › video › 104
2 days ago
Watch Manchester City vs Liverpool live stream and highlights video Watch this game live free online .Liverpool vs Manchester City Highlights & Full Match Video Goals.Liverpool 3 0 Manchester City Live Full Match!!! Reaction Stream!Liverpool vs Man City LIVE Stream Champions League Watchalong. Manchester City 1 2 (1 5) Liverpool Live Full Match!!! Reaction LIVE Liverpool 30 Manchester City (halftime reaction).Liverpool vs Manchester City | 201718 UEFA Champions League HighlightsLiverpool shocks Manchester City 30 in Champions League
Video Liverpool vs Manchester City Highlights Goals
Full Matches and Shows Jan 14, 2018
Web results
Manchester City Liverpool live score, video stream and H2H results
Manchester City Liverpool live score (and video online live stream) starts on Here on SofaScore livescore you can find all Manchester City vs Liverpool
Notices about Filtered Results
In response to a complaint that we received under the US Digital Millennium Copyright Act, we have removed 1 result(s) from this page If you wish, you may read the DMCA complaint that caused the removal(s) at LumenDatabaseorg
Searches related to Liverpool vs Manchester City Live Stream
crystal palace vs man city live streaming
match!!! liverpool vs manchester city live streaming ( ucl ) footbie
Match!!! Liverpool vs Manchester City Live Streaming ( UCL ) Champions League 54, 245 AM Stadium Anfild Round of 8 Leg 1 Click Here
liverpool vs man city live enowcom Content Results
The First Round draw took place on 16 October and was broadcast live Leicester City v Fleetwood Town (Replay) Liverpool Cardiff City v Manchester City
Live Manchester City vs Liverpool Live Streaming Free Online
sfacebookcom › › Stadium, Arena & Sports Venue
Live Manchester City vs Liverpool Live Streaming Free Online, Manchester, United Kingdom 1110 likes · 96 talking about this · 46 were here Stadium,
Live Manchester City vs Liverpool Live Streaming Free Facebook
Live Manchester City vs Liverpool Live Streaming Free Online · March 27 · ,Manchester,,City,,vs,,Liverpool,,Live,Stream,Premier,,League,,2018,,Game,
Watch LiverpoolManchester City live stream NBC Sports Live
How to watch Premier League live stream Liverpool v Manchester City, Matchday 19, on NBC Sports
Watch LiverpoolManchester City live stream NBC Sports Live
How to watch Premier League live stream Liverpool v Manchester City, Matchday 23, on NBC Sports and the NBC Sports app
Watch AC Milan vs Manchester United live stream free Ronaldo7net
Watch AC Milan vs Manchester United live stream Watch this game live and online for free Friendly July 25, 2018
liverpool vs chelsea
mayweather vs mcgregor live stream total sportek
leicester v everton live stream
roma vs barcelona live
qarabag vs chelsea live
spurs v wimbledon live stream
barcelona vs roma live match
Page Navigation
Source: https://groups.drupal.org/node/512931/feed

Common Connected Hardware Blunders

Over the last few years we’ve worked with a number of startups who have engaged with Viget for help designing or engineering some aspect of their connected product. Every product is unique, but it may surprise you how similar their challenges are. What is perhaps less surprising is the number of inventive ways we’ve seen solo-entrepreneurs, young startups, and even internal business units with firm foundations go about solving those challenges. I’ll take a moment to reflect on some of those challenges and specifically call attention to the missteps and follies we commonly see early-on in engagements.

Building the wrong prototype
Viget builds primarily two different kinds of product prototypes. A stakeholder prototype, which focuses on delivering desired functionality by leveraging as many pre-existing solutions as possible. And a functional prototype, which focuses on exploring production options by honing in on core mechanics and functionality. Both prototypes serve specific needs which often correlate with the natural phases of product development. Sometimes the prototype should support buy-in for an idea, other times it should help sell the path forward.
In both situations the prototype is the center of attention. The prototype is what you share with your team, your boss, investors, and your crowd-sourced customers (even your mom!). Because of the spotlight, it needs to behave in ways that put a good foot forward. This is why we’re so surprised when we come across cobbled-together assemblies that supposedly represent a product vision. It might only work because it gets cast alongside a tremendous number of conditions and explanation. I.e: 
“...ignore this part, focus on this, let me articulate this thing by hand to show you want it WILL do...”
We admire the gumption and eagerness to make things — especially from our clients — but instead, consider the alternative: a self-evident prototype. A prototype that stands up on its own and clearly articulates a vision. A good litmus test is what you’ll find when you crack open the enclosure of a connected prototype. Is it something you are proud to share? Or is it a rat's nest of wires with indeterminable purpose? Why not invest the extra time, and the extra money, and dedicate some effort to articulating an effective product vision? Build the prototype that serves its specific purpose and can survive being the center of attention. Anything less and you are wasting time by building the wrong prototype.

Waiting for perfection
Developing connected products, like anything, is a balancing act. Wait too long and over-build a prototype and you’ll become overly invested in one direction. A tempering thought to keep in mind: every day spent on product integrationis a day not on the market. Future you is absolutely going to miss out on that revenue.
Finding the right balance stems from experience. Very plainly, it’s important to figure out which features are necessary for achieving present business goals. This gets complicated, fast, because those objectives change. Connected products benefit from a maturing market which will support any number of value-add services, and business want the flexibility to explore and ultimately choose the right one.
Take a look at Helium as an example. This team has iterated for well over three years on a concept where the underlying technology has morphed just as often as their business. Over time they have developed strong relationships with their community, their customers, and their investors -- demonstrating an ability to not only deliver useful products to the customers they have today, but also develop products for the customers they want tomorrow.

Restless Bill of Materials
Another source of pain I see are business decisions which needlessly accelerate product evolution. A good example is the price of a bill of materials (BOM) conflicting with business or marketing objectives.
Consider a fully-developed production-prototype built on the back of specific MCUs, peripherals, toolings, and plastics. The cost of adjusting this BOM late-stage is significant, not to mention a collective headache. However it is a common occurrence because around the time that something is ready to enter production its total in-the-box cost can be scrutinized. It is around this time a product team will receive an email along these lines:
“We’re trying to keep the device costs down to x, we hit a snag here and so we’re currently at y, anything we can we do?”
The product team will take a good look at low-hanging fruit already earmarked as extravagance.
“We’re currently platformed on x but can go to y which costs z less. But it means we’ll need to re-develop portions of the firmware, re-route this, calibrate that, etc”
Unlike software, hardware is generally less forgiving to constant tweaks and adjustments. It’s an all around better thing to simply nail to the wall correctly the first time. But that is obviously a hard mark to hit, so what options exist?
Go to market regardless with the higher price point.Go to market with the lower (desired) price point. Take it out of the margin, or eat it. Make it up with scale or an equally performant but lower cost v2 in the future.Account for the long-term upside of value-add cloud services (subscription, etc).
I really like options two and three, businesses that maintain a price point and develop margins over time. This is complex to model, and more complex to convey to investors or other stakeholders. However, it keeps the right priorities in place: ship early, develop value-add services, cultivate relationships with suppliers.
Ultimately a restless BOM is indicative of teams not truly collaborating together. There are strategies to hurdle specific challenges, and even aid with hardware versioning, but if the BOM is constantly changing there is little opportunity to build valuable services on top a hardware foundation. And, based on our experience, those value-add services are what matter the most to a connected product businesses.Hit a snag manufacturing your connected product? Tell us about it below or contact us.

Source: VigetInspire

Detecting Motion with PIR Sensors

Recently we needed to determine whether or not movement was occurring in the nearby vicinity of a device. The application was to be used for an interactive art installation (which you can read more about at viget.com/lightwalk), where motion would trigger the activation of lights. We considered a wide array of components to do the job, but ultimately landed on using Passive Infrared Sensors (PIR for short). Here, I'll explain the process by which we got our PIR sensors to report momentary and sustained movement.

The Task

What is it that we wanted exactly? Detect when motion occurs in front of the sensor (between 1 and 10 feet), and continue to detect the motion for as long as it occurs. This covers the two main use cases we were designing for - casually walking by the sensor, and dancing like a maniac (a maaaaniac) in front of the sensor.

The Existing Tech

This is, not surprisingly, a problem that's been solved time and time again. So much so that there are really great proto-boards available to dip your toes into PIR with (ie: SparkFun OpenPIR). PIR sensors are commonly used to power deck and garage lighting that needs to activate whenever motion occurs in some specific area, and they work in pretty much all environmental circumstances (night, day, cloudy, sunny, etc.) Side note: the science behind how PIR sensors work is roughly a cross between infrared waves and the eye of a bug, here's a pre-assembled Wikipedia rabbit hole for you: PIR -> Fresnal Lense -> Anthropod Eye.

Unfortunately for us, we couldn't use an off-the-shelf solution for a number of reasons, mainly that they had to live outside, be tiny, and mount to the side of a 1-inch tube. We ultimately sprung for a batch of industrial PIR sensors, those that are built small and capable of handling all sorts of weather, and then set about determining which one detected motion in the desired focal area.

The Experimentation

We rigged up six different sensors to a pole, and logged the readings each sensor spat out while a coworker made crazy dance motions along a grid (video proof). We then plotted the readings on a spreadsheet and color coded the results to determine where each sensor's sweet spot of motion detection was:

It's not every day that you get to do Actual Science as a software developer! The dark purple blocks represents a "strong" reading, and the graphs here show the results from the three most promising sensors. We ended up going with sensor #1 as it offered the best detection for "right in front of the thing". All this goes to show that every type of sensor behaves differently depending on what kind of lens is fixed to it, and you should pick the one that best suits your needs. (for those curious, we ended up with this one)

The Fine Tuning

Now came the fun part (for me at least) - the coding! PIR sensors output their perception of the world by way of an analog value, a number between 0 and 4096 that describes ... something. That something isn't as straightforward as "a high number means motion is happening" unfortunately. In fact, when something moves drastically in front of a PIR sensor, that analog value moves high and low rather slowly. The graphs above were filled with the lowest value recorded in a set time period, a rudimentary method for detecting motion.

Let's take a look at some graphs visualizing the raw output of a few different scenarios (each graph represents ~7 seconds of time):

Flatline - no motion detected

At rest the sensor outputs a value around 3100.

Quick Motion - wave hand in front of sensor

Motion causes the value to spike low and high at mostly unpredictable rates, and over the course of multiple seconds (milliseconds would have been nice, but this is certainly workable)

Sustained Motion - dance in front of sensor

Sustained motion triggers similar spikes, but with varying amplitudes as time passes

It's easy enough to detect single motion events. When the amplitude of the graph hits a certain threshold in a given timeframe, you have motion. Sustained motion sensing behaves a bit differently however. The amplitude of the wave has it's extremes, but will spend multiple seconds outputting more mild oscillations. Thus, the overall tactic becomes:

Determine initial motion based on the detection of a large oscillation.
Determine sustained motion based on the continued detection of a smaller oscillations.

Let's take a look at one more graph to bring this home. The jagged red line here is the difference between local maximums and minimums recorded at 250ms intervals, and the orange line is the final boolean value answering the question "is something moving in front of the sensor" (25 seconds in total covered here):

There's a single motion near the beginning, and sustained motion for the latter half. Even though there are multiple instances where there is very little activity recorded during the sustained motion, our threshold is set loosely enough that continued motion is still detected until it concretely comes to a stop.

The Code

I'll spare you the minute details, if you're interested in taking a look at the actual code, this gist has everything you need.

In closing, check out these pictures of our little sensors in the wild:

Source: VigetInspire

Getting Ready for Web Video

Inspired Magazine
Inspired Magazine - creativity & inspiration daily
Video is one of those really contentious points about web design. There are some people who feel like web pages should not have embedded video at all. These people are wrong.
Like any technology, however, we should respect it and not abuse it. The two worst things you can do are:

AutoPlay videos, without express consent from the user
Embed too many videos in one page

Both of these things are likely to cause annoyance to users and should be avoided unless you have a very good reason.
Knowing what not to do will only get you so far. The rest of your online video success story will depend on knowing the things you ought to do, which is what we’ll cover in the rest of this article.
Video categories
There are six different types of videos that are commonly used on sites. These are:

Regular video – you point a camera at something and record it
Live stream – you point a camera at something and don’t record it
Slide show – composed from a series of still images, often with voice over plus added descriptive text
Animation – various methods, but more commonly 3D rendered animations made with Maya3D or Blender.
Screencast – software records images from your computer, normally used for tutorials, usually with text overlays and voice narration.
Hybrid screencast – a screen cast with regular video segments, and possibly also slideshow segments.

Knowing which type of video you want to produce is a good start. Actually that brings us neatly to the next topic.
Plan your video
Good video doesn’t normally happen by accident. Meticulous planning pays off, and that means you know what kind of video you’re going to produce, how you’re going to produce it, and (very importantly) why.
Don’t fail to plan. For a start, your video should be scripted. This is true even if there is no dialog or narration. The script gives you a clear impression of how the video is supposed to unfold. You can also optionally story board the video, but a crew that can’t work straight from a script is not a very visionary crew.
If you’re making a bigger production, you’ll also benefit from budget planning, scene breakdown, shooting sequence (shot list), location scouting, etc. The more time you invest into planning, the better your video is likely to be. Professional preparation leads to professional results.
Software that can help you with script writing and planning includes Trelby and CeltX.

Invest in quality equipment
The equipment you use will have a big impact on the result. It may be difficult to believe, but the camera is not the most important part of your equipment investment.
That’s because for web video (in 2018, at least) it’s rarely sensible to shoot video above normal HD (1920px wide), and in fact it’s better to shoot in SD (1280px wide) or lower, and the aspect ratio should always be 16:9.
One source of confusion with these resolutions, by the way, is the slightly misleading standard names used, which references the vertical height (720p / 1080p) rather than the width, which is the most natural thing people think about.
In thinking about this, bear in mind that a video with a frame height of 720px will not fit on the screen real estate of most users, so it is easy to see why shooting above 720p will not give superior results for web video.
The larger your video frame is, the more resources it will hog on the user’s device, including in some cases failing to play at all, or playing very poorly. Your goal really should be to get the highest image quality and the lowest file size (in bytes).
The reason all this is mentioned is because cameras up to HD will be quite inexpensive compared to cameras that can shoot at higher resolutions, and you’ll just be wasting your money if you invest in them, because most users in 2018:

Do not have screens large enough to support the enormous frame size
Do not have connections fast enough to stream anything above HD smoothly
Do not have connections able to stream anything above SD smoothly either
Are not overly concerned about quality as long as it is reasonable

Quality of your content is the more important thing. So cameras for web video are cheap. What matters a lot more is the audio, and that is where you should invest sensibly.
Cheap audio solutions are likely to result in poor results, so avoid cheap audio and invest in quality. What you save on your camera can be reinvested into sound. Literally what you’d regard as a sound investment.

The main microphone types are shotgun, boom, and wireless. The top brands include Rode, Senheiser, Shure, and Audio-Technica.
Shotgun microphones will do the job if the camera is reasonably near and there is no wind. A boom mic can be made from a shotgun mic mounted on a pole with an extension cable. Wireless is the most expensive and the most likely to give you trouble.
You should invest in a good quality tripod as well, with the generally accepted best brand on the market being Manfrotto. What you should invest in lighting depends on the location. Other items you’ll need could include reflectors and shaders.
Completely optional items that can be useful include sliders, dollies, jibs, and lens filters. Don’t invest in these items unless your production warrants their purchase.
Set the scene
The best idea with online video is to keep it short whenever possible, and when it’s not possible, break it down into segments. This is far better than one long continuous narrative, and makes your video look more professional.
For each segment, think about what will be in the frame. If the camera will pan, track, or otherwise follow your movement between two or more points, think about what will be in the frame at each point. Rehearse it and mark the spots where you will stand if you’re in an on-camera role.

How you can mark ground spots is with chalk, tape, small bean bags, or stones. The camera operator should use a tripod or Steadicam for best results. Shaky video is truly horrible.
For screen casts and slideshows, think about how well the user can see what you’re showing. Zoom in on key elements if necessary, and be willing to switch betweeen different zoomed and unzoomed views, as the situation requires.
Make your own green screen
If you are presenting from behind a desk, a green screen can be a big improvement to your presentation. Simply get yourself a large, flat, solid surface, which should be smooth and unblemished, and paint it a bright shade of green.

For ultimate compatibility, also create magenta and cyan screens that can be swapped in if you need to show anything green colored in your frame.
With a green screen (or magenta, or cyan) you can use a technology called chroma key to replace the solid color with any image, including another video.
Obviously there’s not much point in making a video if nobody wants to watch it, so try to keep things interesting. Beware, however, not to be insincere or act out of character, because poor acting is worse than no acting at all.
Humor can be powerful if it is done well, and used only where it is appropriate. Likewise solemn, somber, and scandalous tones can also create interest when used appropriately.
Product videos and testimonials should be delivered enthusiastically and highlight the best features, however product reviews should be brutally honest in order to boost your credibility and win the trust of your viewers. Nothing is more valuable than trust.
Editing your video is the biggest task of all. For this, you’ll need software, and that software must be a nonlinear video editor (NLE). With this you can put mix and match the various clips you’ve shot to make a coherent narrative.

Not all editing software is equal. The best video editors are Cinlerra, Adobe Premiere Pro, Blender, and Sony Vegas Pro.
Rendering is usually done, at least on the first pass, by the video editing software. When rendering for DVD, your goal is to get maximum video quality, regardless of the file size. Rendering for the web is a whole different thing.
The only formats worth considering are MP4 and WEBM, and while the latter will give you a better file size, it is not currently universally supported by all browsers. It is worth keeping in mind for the future.
Although your sound capture needs to be first rate, your rendered audio definitely should not be. In fact this is where most people go wrong, leaving their sound at ridiculously high fidelity when it’s not necessary. Reducing the audio quality will go a long way towards reducing file size while not noticeably affecting the outcome.

Codecs are a hotly debated topic, but the general consensus of professionals is to use the H.264 codec (or equivalent), because this will ensure maximum compatibility and a good balance between quality and file size.
Finally, consider shrinking the physical dimensions of the video if it is going to be viewed within a pre-defined space, and the user would not be expected to view it in full screen mode (doing so will work, but results in pixelation… their problem, not yours).
You can also use video transcoders such as Handbrake for your final render to fine tune the resulting file and ensure maximum compatibility. In some regions ISPs have restricted access to Handbrake downloads, but that’s just a testament to how good it is.
Don’t under-estimate the power of captioning. Investing the time to create proper closed captions (subtitles) for your video production will be a very good investment. At the very least, allow auto-captions, but creating your own, especially if you allow a choice of languages, is always a good idea except when your video contains no speech.
Considering how many mobile users there are and the prevalence of 3G connections, with 4G still being a (slowly growing) minority, HD video is not the best of ideas, and since Vimeo’s support for captioning is not on a par with Google’s, this makes Google the better choice for online video hosting at present.

Notice, however, that it was Google, not YouTube, that got the mention there. For numerous reasons, YouTube is not the best way to host your video, however there is nothing to prevent you uploading multiple versions of your video, one you host on a private Google account and one you host on YouTube.
The version embedded on your site should be the version hosted on your Google account.
The one exception to the rule is if you’re producing feature content, where you are showing off your film making prowess. In this case, Vimeo may have the edge.
For low bandwidth sites (those that attract less traffic than the bandwidth they have available), you could consider hosting the video on your own server. This can provide some advantages, especially in terms of loading time.
This post Getting Ready for Web Video was written by Inspired Mag Team and first appearedon Inspired Magazine.
Source: inspiredm.com

An update on the Layout Initiative for DrupalCoin Blockchain 8.4/8.5

Now DrupalCoin Blockchain 8.4 is released, and DrupalCoin Blockchain 8.5 integrationis underway, it is a good time to give an update on what is happening with DrupalCoin Blockchain's Layout Initiative.
8.4: Stable versions of layout functionality
Traditionally, site builders have used one of two layout solutions in DrupalCoin Blockchain: Panelizer and Panels. Both are contributed modules outside of DrupalCoin Blockchain core, and both achieved stable releases in the middle of 2017. Given the popularity of these modules, having stable releases closed a major functionality gap that prevented people from building sites with DrupalCoin Blockchain 8.
8.4: A Layout API in core
The Layout Discovery module added in DrupalCoin Blockchain 8.3 core has now been marked stable. This module adds a Layout API to core. Both the aforementioned Panelizer and Panels modules have already adopted the new Layout API with their 8.4 release. A unified Layout API in core eliminates fragmentation and encourages collaboration.
8.5+: A Layout Builder in core
Today, DrupalCoin Blockchain's layout management solutions exist as contributed modules. Because creating and building layouts is expected to be out-of-the-box functionality, we're working towards adding layout building capabilities to DrupalCoin Blockchain core.
Using the Layout Builder, you start by selecting predefined layouts for different sections of the page, and then populate those layouts with one or more blocks. I showed the Layout Builder in my DrupalCoin BlockchainCon Vienna keynote and it was really well received:
[youtube https://www.youtube.com/watch?v=Hx4EEzI7aNE?rel=0&w=640&h=360]
8.5+: Use the new Layout Builder UI for the Field Layout module
One of the nice improvements that went in DrupalCoin Blockchain 8.3 was the Field Layout module, which provides the ability to apply pre-defined layouts to what we call "entity displays". Instead of applying layouts to individual pages, you can apply layouts to types of content regardless of what page they are displayed on. For example, you can create a content type 'Recipe' and visually lay out the different fields that make up a recipe. Because the layout is associated with the recipe rather than with a specific page, recipes will be laid out consistently across your website regardless of what page they are shown on.
The basic functionality is already included in DrupalCoin Blockchain core as part of the experimental Fields Layout module. The goal for DrupalCoin Blockchain 8.5 is to stabilize the Fields Layout module, and to improve its user experience by using the new Layout Builder. Eventually, designing the layout for a recipe could look like this:

Layouts remains a strategic priority for DrupalCoin Blockchain 8 as it was the second most important site builder priority identified in my 2016 State of DrupalCoin Blockchain survey, right behind Migrations. I'm excited to see the work already accomplished by the Layout team, and look forward to seeing their progress in DrupalCoin Blockchain 8.5! If you want to help, check out the Layout Initiative roadmap.
Special thanks to Angie Byron for contributions to this blog post, to Tim Plunkett and Kris Vanderwater for their feedback during the writing process, and to Emilie Nouveau for the screenshot and video contributions.
Source: Dries Buytaert www.buytaert.net

Professional Video Game Player

This was a dream of mine, at one point, but, the reality is that I’m not that amazing at video games and broadcasting while playing isn’t something that I’m interested in.
But, there was a time when I thought being in the video game industry full-time would be where I’d eventually end up and where I thought I’d be the most happy.

This was entirely do to the fact that video games is the thing that got me into software programming – I just wanted to build things that I could play myself and through creating my own mini-games to modifying maps for my friends, I believed the industry had a spot for me.
It wasn’t that I grew up and grew out of it; I just realized that to make it work would require a different type of person, someone that wasn’t me.
So, I won’t be getting rich playing video games. Not today or ever… and I’m really happy about that. Video games has a specific spot in my heart and on my calendar that’s fluid and fair.
More importantly, though, at least from a professional perspective, I’m really glad that I don’t bank on my gaming skills to earn an income… because I’d be dead-broke.
Now… if I could only find some time for the new Call of Duty that I pre-ordered months ago and came out last week…
[Funny: My dad sent me the New Yorker article.]
The post Professional Video Game Player appeared first on John Saddington.
Source: https://john.do/

Robust React User Interfaces with Finite State Machines

User interfaces can be expressed by two things:

The state of the UI
Actions that can change that state

From credit card payment devices and gas pump screens to the software that your company creates, user interfaces react to the actions of the user and other sources and change their state accordingly. This concept isn't just limited to technology, it's a fundamental part of how everything works:

For every action, there is an equal and opposite reaction.
- Isaac Newton

This is a concept we can apply to developing better user interfaces, but before we go there, I want you to try something. Consider a photo gallery interface with this user interaction flow:

Show a search input and a search button that allows the user to search for photos
When the search button is clicked, fetch photos with the search term from Flickr
Display the search results in a grid of small sized photos
When a photo is clicked/tapped, show the full size photo
When a full-sized photo is clicked/tapped again, go back to the gallery view

Now think about how you would develop it. Maybe even try programming it in React. I'll wait; I'm just an article. I'm not going anywhere.
Finished? Awesome! That wasn't too difficult, right? Now think about the following scenarios that you might have forgotten:

What if the user clicks the search button repeatedly?
What if the user wants to cancel the search while it's in-flight?
Is the search button disabled while searching?
What if the user mischievously enables the disabled button?
Is there any indication that the results are loading?
What happens if there's an error? Can the user retry the search?
What if the user searches and then clicks a photo? What should happen?

These are just some of the potential problems that can arise during planning, development, or testing. Few things are worse in software integrationthan thinking that you've covered every possible use case, and then discovering (or receiving) new edge cases that will further complicate your code once you account for them. It's especially difficult to jump into a pre-existing project where all of these use cases are undocumented, but instead hidden in spaghetti code and left for you to decipher.
Stating the obvious
What if we could determine all possible UI states that can result from all possible actions performed on each state? And what if we can visualize these states, actions, and transitions between states? Designers intuitively do this, in what are called "user flows" (or "UX Flows"), to depict what the next state of the UI should be depending on the user interaction.
Picture credit: Simplified Checkout Process by Michael Pons
In computer science terms, there is a computational model called finite automata, or "finite state machines" (FSM), that can express the same type of information. That is, they describe which state comes next when an action is performed on the current state. Just like user flows, these finite state machines can be visualized in a clear and unambiguous way. For example, here is the state transition diagram describing the FSM of a traffic light:

What is a finite state machine?
A state machine is a useful way of modeling behavior in an application: for every action, there is a reaction in the form of a state change. There's 5 parts to a classical finite state machine:

A set of states (e.g., idle, loading, success, error, etc.)
A set of actions (e.g., SEARCH, CANCEL, SELECT_PHOTO, etc.)
An initial state (e.g., idle)
A transition function (e.g., transition('idle', 'SEARCH') == 'loading')
Final states (which don't apply to this article.)

Deterministic finite state machines (which is what we'll be dealing with) have some constraints, as well:

There are a finite number of possible states
There are a finite number of possible actions (these are the "finite" parts)
The application can only be in one of these states at a time
Given a currentState and an action, the transition function must always return the same nextState (this is the "deterministic" part)

Representing finite state machines
A finite state machine can be represented as a mapping from a state to its "transitions", where each transition is an action and the nextState that follows that action. This mapping is just a plain JavaScript object.
Let's consider an American traffic light example, one of the simplest FSM examples. Assume we start on green, then transition to yellow after some TIMER, and then RED after another TIMER, and then back to green after another TIMER:
const machine = {
green: { TIMER: 'yellow' },
yellow: { TIMER: 'red' },
red: { TIMER: 'green' }
const initialState = 'green';
A transition function answers the question:
Given the current state and an action, what will the next state be?
With our setup, transitioning to the next state based on an action (in this case, TIMER) is just a look-up of the currentState and action in the machine object, since:

machine[currentState] gives us the next action mapping, e.g.: machine['green'] == {TIMER: 'yellow'}
machine[currentState][action] gives us the next state from the action, e.g.: machine['green']['TIMER'] == 'yellow':
// ...
function transition(currentState, action) {
return machine[currentState][action];

transition('green', 'TIMER');
// => 'yellow'

Instead of using if/else or switch statements to determine the next state, e.g., if (currentState === 'green') return 'yellow';, we moved all of that logic into a plain JavaScript object that can be serialized into JSON. That's a strategy that will pay off greatly in terms of testing, visualization, reuse, analysis, flexibility, and configurability.
See the Pen Simple finite state machine example by David Khourshid (@davidkpiano) on CodePen.
Finite State Machines in React
Taking a look at a more complicated example, let's see how we can represent our gallery app using a finite state machine. The app can be in one of several states:

start - the initial search page view
loading - search results fetching view
error - search failed view
gallery - successful search results view
photo - detailed single photo view

And several actions can be performed, either by the user or the app itself:

SEARCH - user clicks the "search" button
SEARCH_SUCCESS - search succeeded with the queried photos
SEARCH_FAILURE - search failed due to an error
CANCEL_SEARCH - user clicks the "cancel search" button
SELECT_PHOTO - user clicks a photo in the gallery
EXIT_PHOTO - user clicks to exit the detailed photo view

The best way to visualize how these states and actions come together, at first, is with two very powerful tools: pencil and paper. Draw arrows between the states, and label the arrows with actions that cause transitions between the states:
We can now represent these transitions in an object, just like in the traffic light example:
const galleryMachine = {
start: {
SEARCH: 'loading'
loading: {
SEARCH_SUCCESS: 'gallery',
CANCEL_SEARCH: 'gallery'
error: {
SEARCH: 'loading'
gallery: {
SEARCH: 'loading',
photo: {
EXIT_PHOTO: 'gallery'

const initialState = 'start';
Now let's see how we can incorporate this finite state machine configuration and the transition function into our gallery app. In the App's component state, there will be a single property that will indicate the current finite state, gallery:
class App extends React.Component {
constructor(props) {

this.state = {
gallery: 'start', // initial finite state
query: '',
items: []
// ...
The transition function will be a method of this App class, so that we can retrieve the current finite state:
// ...
transition(action) {
const currentGalleryState = this.state.gallery;
const nextGalleryState =

if (nextGalleryState) {
const nextState = this.command(nextGalleryState, action);

gallery: nextGalleryState,
...nextState // extended state
// ...
This looks similar to the previously described transition(currentState, action) function, with a few differences:

The action is an object with a type property that specifies the string action type, e.g., type: 'SEARCH'
Only the action is passed in since we can retrieve the current finite state from this.state.gallery
The entire app state will be updated with the next finite state, i.e., nextGalleryState, as well as any extended state (nextState) that results from executing a command based on the next state and action payload (see the "Executing commands" section)

Executing commands
When a state change occurs, "side effects" (or "commands" as we'll refer to them) might be executed. For example, when a user clicks the "Search" button and a 'SEARCH' action is emitted, the state will transition to 'loading', and an async Flickr search should be executed (otherwise, 'loading' would be a lie, and developers should never lie).
We can handle these side effects in a command(nextState, action) method that determines what to execute given the next finite state and action payload, as well as what the extended state should be:
// ...
command(nextState, action) {
switch (nextState) {
case 'loading':
// execute the search command
case 'gallery':
if (action.items) {
// update the state with the found items
return { items: action.items };
case 'photo':
if (action.item) {
// update the state with the selected photo item
return { photo: action.item };
// ...
Actions can have payloads other than the action's type, which the app state might need to be updated with. For example, when a 'SEARCH' action succeeds, a 'SEARCH_SUCCESS' action can be emitted with the items from the search result:
// ...
{ jsonpCallback: 'jsoncallback' })
.then(res => res.json())
.then(data => {
this.transition({ type: 'SEARCH_SUCCESS', items: data.items });
.catch(error => {
this.transition({ type: 'SEARCH_FAILURE' });
// ...
The command() method above will immediately return any extended state (i.e., state other than the finite state) that this.state should be updated with in this.setState(...), along with the finite state change.
The final machine-controlled app
Since we've declaratively configured the finite state machine for the app, we can render the proper UI in a cleaner way by conditionally rendering based on the current finite state:
// ...
render() {
const galleryState = this.state.gallery;

return (
<div className="ui-app" data-state={galleryState}>
// ...
The final result:
See the Pen Gallery app with Finite State Machines by David Khourshid (@davidkpiano) on CodePen.
Finite state in CSS
You might have noticed data-state={galleryState} in the code above. By setting that data-attribute, we can conditionally style any part of our app using an attribute selector:
.ui-app {
// ...

&[data-state="start"] {
justify-content: center;

&[data-state="loading"] {
.ui-item {
opacity: .5;
This is preferable to using className because you can enforce the constraint that only a single value at a time can be set for data-state, and the specificity is the same as using a class. Attribute selectors also supported in most popular CSS-in-JS solutions.
Advantages and resources
Using finite state machines for describing the behavior of complex applications is nothing new. Traditionally, this was done with switch and goto statements, but by describing finite state machines as a declarative mapping between states, actions, and next states, you can use that data to visualize the state transitions:

Furthermore, using declarative finite state machines allows you to:

Store, share, and configure application logic anywhere - similar components, other apps, in databases, in other languages, etc.
Make collaboration easier with designers and project managers
Statically analyze and optimize state transitions, including states that are impossible to reach
Easily change application logic without fear
Automate integration tests

Conclusion and takeaways
Finite state machines are an abstraction for modeling the parts of your app that can be represented as finite states, and almost all apps have those parts. The FSM coding patterns presented in this article:

Can be used with any existing state management setup; e.g., Redux or MobX
Can be adapted to any framework (not just React), or no framework at all
Are not written in stone; the developer can adapt the patterns to their coding style
Are not applicable to every single situation or use-case

From now on, when you encounter "boolean flag" variables such as isLoaded or isSuccess, I encourage you to stop and think about how your app state can be modeled as a finite state machine instead. That way, you can refactor your app to represent state as state === 'loaded' or state === 'success', using enumerated states in place of boolean flags.
I gave a talk at React Rally 2017 about using finite automata and statecharts to create better user interfaces, if you want to learn more about the motivation and principles:
[youtube https://www.youtube.com/watch?v=VU1NKX6Qkxc&w=560&h=315]
Slides: Infinitely Better UIs with Finite Automata
Here are some further resources:

Pure UI by Guillermo Rauch
Pure UI Control by Adam Solove
Wikipedia: Finite State Machines
Statecharts: A Visual Formalism for Complex Systems by David Harel (PDF)
Managing State in JavaScript with State Machines by Krasimir Tsonev
Rambling Thoughts on React and Finite State Machines by Ryan Florence

Robust React User Interfaces with Finite State Machines is a post from CSS-Tricks
Source: CssTricks

An update on the Media Initiative for DrupalCoin Blockchain 8.4/8.5

In my blog post, "A plan for media management in DrupalCoin Blockchain 8", I talked about some of the challenges with media in DrupalCoin Blockchain, the hopes of end users of DrupalCoin Blockchain, and the plan that the team working on the Media Initiative was targeting for future versions of DrupalCoin Blockchain 8. That blog post is one year old today. Since that time we released both DrupalCoin Blockchain 8.3 and DrupalCoin Blockchain 8.4, and DrupalCoin Blockchain 8.5 integrationis in full swing. In other words, it's time for an update on this initiative's progress and next steps.
8.4: a Media API in core
DrupalCoin Blockchain 8.4 introduced a new Media API to core. For site builders, this means that DrupalCoin Blockchain 8.4 ships with the new Media module (albeit still hidden from the UI, pending necessary user experience improvements), which is an adaptation of the contributed Media Entity module. The new Media module provides a "base media entity". Having a "base media entity" means that all media assets — local images, PDF documents, YouTube videos, tweets, and so on — are revisable, extendable (fieldable), translatable and much more. It allows all media to be treated in a common way, regardless of where the media resource itself is stored. For end users, this translates into a more cohesive content authoring experience; you can use consistent tools for managing images, videos, and other media rather than different interfaces for each media type.
8.4+: porting contributed modules to the new Media API
The contributed Media Entity module was a "foundational module" used by a large number of other contributed modules. It enables DrupalCoin Blockchain to integrate with Pinterest, Vimeo, Instagram, Twitter and much more. The next step is for all of these modules to adopt the new Media module in core. The required changes are laid out in the API change record, and typically only require a couple of hours to complete. The sooner these modules are updated, the sooner DrupalCoin Blockchain's rich media ecosystem can start benefitting from the new API in DrupalCoin Blockchain core. This is a great opportunity for intermediate contributors to pitch in.
8.5+: add support for remote video in core
As proof of the power of the new Media API, the team is hoping to bring in support for remote video using the oEmbed format. This allows content authors to easily add e.g. YouTube videos to their posts. This has been a long-standing gap in DrupalCoin Blockchain's out-of-the-box media and asset handling, and would be a nice win.
8.6+: a Media Library in core
The top two requested features for the content creator persona are richer image and media integration and digital asset management.
The results of the State of DrupalCoin Blockchain 2016 survey show the importance of the Media Initiative for content authors.

With a Media Library content authors can select pre-existing media from a library and easily embed it in their posts. Having a Media Library in core would be very impactful for content authors as it helps with both these feature requests.
During the 8.4 integrationcycle, a lot of great work was done to prototype the Media Library discussed in my previous Media Initiative blog post. I was able to show that progress in my DrupalCoin BlockchainCon Vienna keynote:
[youtube https://www.youtube.com/watch?v=S82paYMycNE?rel=0&w=640&h=360]
The Media Library work uses the new Media API in core. Now that the new Media API landed in DrupalCoin Blockchain 8.4 we can start focusing more on the Media Library. Due to bandwidth constraints, we don't think the Media Library will be ready in time for the DrupalCoin Blockchain 8.5 release. If you want to help contribute time or funding to the integrationof the Media Library, have a look at the roadmap of the Media Initiative or let me know and I'll get you in touch with the team behind the Media Initiative.
Special thanks to Angie Byron for contributions to this blog post and to Janez Urevc, Sean Blommaert, Marcos Cano Miranda, Adam G-H and Gábor Hojtsy for their feedback during the writing process.
Source: Dries Buytaert www.buytaert.net

A Reasonable Approach for Getting Comfortable With Command Line

Considering how much the command line is an integral part of the developer's workflow, it should not be thought overly difficult or tedious to learn.
At one time I avoided it myself, but one day began teaching myself ways to make the difficult as easy as it should be. I got over the hurdle, and you can too. It was worth investing my time to increase my command line comfort-level, and I am going to share a few tips and resources that I found helpful in this post.
The intended reader is the type who typically avoids the command line, or perhaps uses it occasionally but not as a regular or essential tool.

Tip #1: Maintain a Pragmatic Mindset
The way to get more comfortable with the command line is this: practice. You practice, and you get better. There is no secret trick to this; study and repetition of skills will turn into understanding and mastery. There is no use in the mindset that you cannot do this; it will only keep you from your goal. You may as well discard such thoughts and get down to it.
Tip #2: Keep a Cheat sheet
Don't be afraid to keep a cheat sheet. I find that a thin, spiral-bound notebook kept next to my keyboard is perfect; writing the command down helps commit it to memory; having it in a place where I can refer to it while I am typing is convenient to the process. Do not permit yourself merely to copy and paste; you will not learn this way. Until you know the command, make yourself type it out.
Tip #3: Peruse languages outside of the one(s) you normally use

Spend time looking at commands in various languages, looking at the commands even if you don't immediately absorb, use, or remember them. It is worth it to invest a bit of time regularly, looking at these commands; patterns will eventually emerge. Some of them may even come back to you at an unexpected time and give you an extra eureka moment!
Skimming through books with lots of CLI commands can prove interestingly useful for recognizing patterns in commands. I even take this one step further by getting my favorites spiral-bound. I am a big fan of spiral binding; a place like FedEx offers coil binding services at a surprisingly low cost.

Tip #4: Practice... safely
When I am advising someone who is new to contributing to open source, they are inevitably a bit nervous about it. I think this is perfectly natural if only to comfort myself that my own nervousness about it was perfectly natural. A good way to practice, though, is to set up your own repository for a project and regularly commit to it. Simply using common Git commands in a terminal window to commit inconsequential changes to a project of your own, will establish the "muscle memory" so that when it does come time to actually commit code of consequence, you won't be held back by still being nervous about the commands themselves.
These are the commands I have noticed most common to use in the practical day-to-day of development. It's perfectly acceptable to expect yourself to learn these and to be able to do any of them without a second thought. Do not use a GUI tool (they make weird merge choices). Learn how to write these commands yourself.

Check status
Create a new branch and switch to it
Add files

Add all the changes
Just add one of the changes

Push to a remote branch
Get a list of your branches
Checkout a branch
Delete a branch
Delete a branch even if there are changes
Fetch and merge the changes to a branch

Syncing a fork took longer to learn- I don't often spend my work hours writing code for a repository that I don't have access to. While contributing to open source software, however, I had to learn how to do this. The GitHub article about the topic is sufficient; even now I still have it bookmarked.
Tip #5: Level Up!
I really enjoy using Digital Ocean to level up my skills. Their step-by-step guides are really useful, and for $5 USD per month, "Droplets" are a cost-effective way to do so.
Here's a suggested self-learning path (which, feel free to choose your own adventure! There are over 1700 tutorials in the Digital Ocean community):

Create a Droplet with Ghost pre-installed. There is a little command line work to finalize the installation, which makes it a good candidate. It's not completely done for you but there's not so much to do that it's overwhelming. There's even an excellent tutorial already written by Melissa Anderson.
Set up a GitHub repo to work on a little theming for Ghost, making small changes and practice your command line work.

It would be remiss of me to write any guide without mentioning Ember, as the ember-cli is undoubtedly one of the strongest there is. Feel free to head over to the docs and read that list!
There may be some that find this brief guide too simplistic. However, as famously said by S. Thompson in Calculus Made Easy- "What one fool can do, other fools can do also." Don't let anyone else make you think that using the command line is horribly difficult, or that they are a genius because they can. With practice, you will be able to do it, and it will soon be a simple thing.

A Reasonable Approach for Getting Comfortable With Command Line is a post from CSS-Tricks
Source: CssTricks

Shopping with augmented reality

Last spring, Acquia Labs built a chatbot prototype that helps customers choose recipes and plan shopping lists with dietary restrictions and preferences in mind. The ability to interact with a chatbot assistant rather than having to research and plan everything on your own can make grocery shopping much easier. We wanted to take this a step further and explore how augmented reality could also improve the shopping experience.

[youtube https://www.youtube.com/watch?v=ZroFBG7-P7Q&w=640&h=360]The demo video above features how a shopper named Alex can interact with an augmented reality application to remove friction from her shopping experience at Freshland Market (a fictional grocery store). The Freshland Market mobile application not only guides Alex through her shopping list but also helps her to make more informed shopping decisions through augmented reality overlays. It superimposes useful information such as price, user ratings and recommended recipes, over shopping items detected by a smartphone camera. The application can personalize Alex's shopping experience by highlighting products that fit her dietary restrictions or preferences.

What is exciting about this demo is that the Acquia Labs team built the Freshland Market application with DrupalCoin Blockchain 8 and augmented reality technology that is commercially available today.

The first step in developing the application was to use an augmented reality library, Vuforia, which identifies pre-configured targets. In our demo, these targets are images of product labels, such as the tomato sauce and cereal labels shown in the video. Each target is given a unique ID. This ID is used to query the Freshland Market DrupalCoin Blockchain site for content related to that target.

The Freshland Market site stores all of the product information in DrupalCoin Blockchain, including price, dietary concerns, and reviews. Thanks to DrupalCoin Blockchain's web services support and the JSON API module, DrupalCoin Blockchain 8 can serve content to the Freshland Market application. This means that if the DrupalCoin Blockchain content for Rosemary & Olive Oil chips is edited to mark the item on sale, this will automatically be reflected in the content superimposed through the mobile application.

In addition to information on price and nutrition, the Freshland Market site also stores the location of each product. This makes it possible to guide a shopper to the product's location in the store, evolving the shopping list into a shopping route. This makes finding grocery items easy.

Augmented reality is building momentum because it moves beyond the limits of a traditional user interface, or in our case, the traditional website. It superimposes a digital layer onto a user's actual world. This technology is still emerging, and is not as established as virtual assistants and wearables, but it continues to gain traction. In 2016, the augmented reality market was valued at $2.39 billion and it is expected to reach $61.39 billion by 2023.

What is exciting is that these new technology trends require content management solutions. In the featured demo, there is a large volume of product data and content that needs to be managed in order to serve the augmented reality capabilities of the Freshland Market mobile application. The DrupalCoin Blockchain community's emphasis on making DrupalCoin Blockchain API-first in addition to supporting distributions like Reservoir means that DrupalCoin Blockchain 8 is prepared to support emerging channels.

If you are ready to start reimagining how your organization interacts with its users, or how to take advantage of new technology trends, Acquia Labs is here to help.

Special thanks to Chris Hamper and Preston So for building the Freshland Market augmented reality application, and thank you to Ash Heath and Drew Robertson for producing the demo video.
Source: Dries Buytaert www.buytaert.net

How Different CMS’s Handle Content Blocks

Imagine a very simple blog. Blog posts are just a title and a paragraph or three. In that case, having a CMS where you enter the title and those paragraphs and hit publish is perfect. Perhaps some metadata like the date and author come along for the ride. I'm gonna stick my neck out here and say that title-and-content fields only is a CMS anti-pattern. It's powerful in its flexibility but causes long-term pain in lack of control through abstraction.

Let's not have a conversation about CMS's as a whole though, let's scope this down to just that content area issue.
Now imagine we have a site with a bit more variety. We're trying to use our CMS to build all sorts of pages. Perhaps some of it is bloggish. Some of it more like landing pages. These pages are constructed from chunks of text but also different components. Maps! Sliders! Advertising! Pull quotes!
Here are four different examples, so you can see exactly what I mean:

I bet that kind of thing looks familiar.
You can absolutely pull this off by putting all those blocks into a single content field. Hey, it's just HTML! Put the HTML you need for all these blocks right into that content field and it'll do what you want.
There's a couple of significant problems with this:

Not everyone is super handy with HTML. You might be setting up a CMS for other people to use who are great with content but not so much with code. Even for those folks who are comfortable with HTML, this doesn't leverage the CMS very well. It would be a lot easier, for example, to rearrange a page by dragging and dropping then it could carefully copy and pasting HTML.
The HTML-in-the-database issue. So you have five pages with an image slider. The slider requires some specific, nested, structured HTML. Are you dropping that into five different pages? That slider is bound to change, and you'll want to avoid changing it five times. Keep your HTML in templates, and data in databases.

So... what do we do? I wasn't really sure how CMS's were handling this, to be honest. So I looked around. This is what I've found.
In CraftCMS...
CraftCMS has a Matrix field type for this.
A single Matrix field can have as many types of blocks as needed, which the author can pick and choose from when adding new content. Each block type gets its own set of fields.
[vimeo 104052531 w=640 h=360]
In Perch...
Perch handles this with what they call Blocks:
In our blog template, the body of the post is just one big area to add text. Your editor, however, might want to build up a post with images, or video, or anything else. We can give them the ability to choose between different things to put into their post using Perch Blocks.
[youtube https://www.youtube.com/watch?v=MsgMhTFConA&w=560&h=315]
In Statamic...
Statamic deals with this idea with Replicator meta fieldtype:
The Replicator is a meta fieldtype giving you the ability to define sets of fields that you can dynamically piece together in whatever order and arrangement you imagine.

In WordPress...
It's tempting to just shout out Advanced Custom Fields here, which seems right up this alley. I love ACF, but I don't think it's quite the same here. While you can create new custom fields to use, it's then on you to ask for that data and output it in templates in a special way. It's not a way of handling the existing content blocks.
Something like SiteOrigin Page Builder, which works by using the existing content area and widgets:
[vimeo 114529361 w=640 h=360]
There is also the forthcoming Gutenberg editor. It's destined for WordPress core, but for now it's a plugin. Brian Jackson has a good article covering it. In the demo content of Gutenberg itself it explains it well:
The goal of this new editor is to make adding rich content to WordPress simple and enjoyable. This whole post is composed of pieces of content - somewhat similar to LEGO bricks - that you can move around an interact with. Move your cursor around and you'll notice differnet blocks light up with outlines and arrows. Press the arrows to reposition blocks quickly, whichout fearing about losing things in the process of copying and pasting.
Note the different blocks available:

In DrupalCoin Blockchain...
DrupalCoin Blockchain has a module called Paragraphs for this:
Instead of putting all their content in one WYSIWYG body field including images and videos, end-users can now choose on-the-fly between pre-defined Paragraph Types independent from one another. Paragraph Types can be anything you want from a simple text block or image to a complex and configurable slideshow.

In ModX...
ModX has a paid add-on called ContentBlocks for this:

The Modular Content principle means that you break up your content into smaller pieces of content, that can be used or parsed separately. So instead of a single blob of content, you may set a headline, an image and a text description.
Each of those small blocks of content have their own template so you can do amazing things with their values.

Of course those aren't the only CMS's on the block. How does yours handle it?

How Different CMS’s Handle Content Blocks is a post from CSS-Tricks
Source: CssTricks

Freelance Graphic Designer - Tamberra - Sarasota, FL

The ability to take existing pre-built WordPress, DrupalCoin Blockchain, or Joomla themes and create mockups based on the available look and feel found in demos, that...
From Indeed - Fri, 22 Sep 2017 21:04:31 GMT - View all Sarasota, FL jobs
Source: http://rss.indeed.com/rss?q=DrupalCoin Blockchain+Developer

Unpacking the Mysteries of Webpack -- A Novice's Journey

I'd worked on a handful of JavaScript applications with
webpack before I inherited one in particular that had
painfully sluggish builds. Even the incremental builds were taking up to 20
seconds...every single time I saved a change to a JS file. Being able to detect
code changes and push them into my browser is a great feedback loop to have
during development, but it kind of defeats the purpose when it takes so long.

What's more, as a compulsive saver and avid collector of Chrome tabs, I basically
lit my computer on fire as it screamed like an F-15 every time webpack ran one of
these builds. I put up with this for awhile because I was scared of webpack.
I shot a handful of awkward glances at webpack.config.js over the course of
a few weeks. Right before permanent madness set in, I resolved to make things
better. Thus started my journey into webpack.

What are you, webpack?

First off, what exactly is this webpack and what does it do? Let's ask

webpack is a module bundler for modern JavaScript applications. When webpack processes your application, it recursively builds a dependency graph that includes every module your application needs, then packages all of those modules into a small number of bundles - often only one - to be loaded by the browser.

In development, webpack does an initial build and serves the resulting bundles
to localhost. Then, as mentioned earlier, it will re-build every time it
detects a change to a file that's in one of those bundles. That's our
incremental build. webpack tries to be smart and efficient when building
assets into bundles. I had suspicions that the webpack configuration on the
project was the equivalent of tying a sack of bricks to its ankles.

First off, I had to figure out what exactly I was looking at inside my webpack
config. After a bit of Googling and a short jaunt over to my
I discovered the project was using version 1.15.0 and the current version was
2.4.X. Usually newer is better -- and possibly faster as well -- so that's
where I decided to start.

Next stop, webpack documentation! I was
delighted to find webpack's documentation included a
migration guide for going from
v1 to v2. Usually migration guides do one of two things:

Make me realize how little I actually know about the thing and confuse me further.

Thankfully, upgrading webpack through the migration guide wasn't bad at all. It
highlighted all the major configuration options I'd need to update and gave me
just enough information to get it done without getting too in the weeds.

10/10, would upgrade again.

At this point, I had webpack 2 installed but I still had an incomplete
understanding of what was actually in my config and how it was affecting any
given webpack build. Fortunately, I work with a lot of smart, experienced
Javascript developers that were able to point out a few critical pieces of
configuration that needed attention. Focusing in on those, I started to learn
more about what was going on under the hood as well as ways to speed things up
without sacrificing build integrity. Before we get there though, let's take a
pit stop and discuss terminology.

webpack, you talk funny.

As I was going through this process, I encountered a lot of terminology I hadn't
run into before. In webpack land, saying something like "webpack dev server hot
reloads my chunks" makes sense. It took some time to figure out what webpack
terms like "loaders", "hot module replacement", and "chunks" meant.

Here are some simple explanations:

Hot Module
Replacement is the
process by which webpack dev server
watches your project directory for code changes and then automatically
rebuilds and pushes the updated bundles to the browser.
Loaders are file processors that run sequentially during a build.
are a lower-level concept in webpack where code is organized into groups to
optimize hot module replacement

Paul Sherman's post was
helpful early on for giving me some perspective on webpack terminlogy outside of
webpack's own documentation. I'd suggest
checking both of them out.

Now that we all understand each other a little better, let's dig into some of
the steps I took during my dive into webpack.

Babel and webpack

Babel is a Javascript compile tool that let's you utilize
modern language features (like Javascript
when you're writing code while minimizing browser and browser-version support
concerns. Coming from Ruby, I love so much about ES6 and ES7. Thanks Babel!

But wait, weren't we talking about webpack? Right. So Babel has a webpack
loader that will plug into the build process. In webpack 2, you use loaders
inside rules in the top-level module config setting. Here's a sizzlin'

// webpack.config.js
module: {
rules: [
test: /.jsx?$/,
exclude: /node_modules/,
loader: 'babel-loader',
options: {
cacheDirectory: '.babel-cache'

There are two particularly spicy bits in there that'll speed up your builds.

Exclude /node_modules/ (directory and everything inside it) -- most
libraries don't require you to run Babel over them in order for them to work.
No need to burden Babel with extra parsing and compilation!
Cache Babel's work -- turns out the Babel loader doesn't have to start from
scratch every time. Add an arbitrary place for the Babel loader to keep a cache
and you'll see build time improvements.

The speed, I can almost taste it. Let's not stop there though, because
Babel has its own config -- .babelrc that needs tending to. In particular,
when using the es2015 preset for Babel, turning the modules setting to false
sped up incremental build times:

// .babelrc
"presets": [
["es2015", { "modules": false }],

Turns out that webpack is capable of handling import statements itself and it
doesn't need Babel to do any extra work to help it figure out what to do.
Without turning the modules setting off, both webpack and Babel are trying to
handle modules.

Riding the Rainbow with Webpack Bundle Analyzer

While searching the interwebs for webpack optimization strategies, I stumbled
It's a plugin for webpack that will -- during build -- spin up a server that
opens a visual, interactive representation of the bundles generated by webpack
for the browser. Feast your eyes on the majestic peacock of the webpack

So majestic. If you're like me, eventually you'd ask yourself, "But.. what does
it mean!?". Got u fam.

Each colored section represents a bundle, visualizing its contents and their
relative size. You're able to mouse over any of the files to get specifics
on size and path. I didn't really know how to organize bundles and their contents,
but I did notice a few things immediately based on the visual output of the

Stuff from node_modules in both bundles
Big .json files in the middle of bundle.js
A million things from react-icon bloating node_modules inside my main
bundle.js. Ack! I'm sure react-icons is a great package, but are we really
using hundreds of distinct icons? Not even close.

My next task was straightforward -- in concept -- but it took me awhile to
figure out how to address each of those issues. Here's what I ended up with:

Thanks to the bundle analyzer, I learned some helpful things along the way.
I'll step through the solutions to each of the problems I listed above.

Vendor Code Appearing in Multiple Bundles

Solution: CommonsChunkPlugin

Using CommonsChunkPlugin, I was able to extract all vendor code (files in
node_modules and manifest-related code (webpack boilerplate that helps the
browser handle its bundles) into their own bundles. Here's some of the related
config straight out of my webpack.config.js:

plugins: [
new webpack.optimize.CommonsChunkPlugin({
name: 'vendor',
minChunks: function(module) {
return module.context && module.context.indexOf('node_modules') !== -1

new webpack.optimize.CommonsChunkPlugin({
name: 'manifest'

Big .json Files in the Main Bundle

Solution: Asynchronous Imports

The app was only using the JSON files in a few React components. Rather than
using import at the top of my React component files, I moved the import
statements into the componentWillMount function (lifecycle callback). When
webpack parses import statements inside functions, it knows to separate those
files into their own bundles. The browser will download them as needed rather
than up front.

Unused Dependencies

Solution: Single File Imports

With react-icons in particular, there are multiple ways to import icons.
Originally, the import statements looked like this:
import CloseIcon from 'react-icons/md/close'

react-icons also has a compiled folder (./lib) where pre-built icon files can
be imported directly. Updating the import statements to use the icons from that
path eliminated the extra bloat:
import CloseIcon from 'react-icons/lib/md/close'

That covers the things I learned from the bundle analyzer. To wrap up, I'll cover
one other webpack config option that made a big difference.

Pick the Right devtool

Last, and certainly not least, is the
devtool config setting
in webpack. The devtool in webpack does the work of generating source maps.
There are a number of options that all approach source map generation differently,
making tradeoffs between build time and quality/accuracy. After trying out a
number of the available source map tools, I landed on this configuration:

// webpack.config.js
devtool: isProd ? 'source-map' : 'cheap-module-inline-source-map',

webpack documentation recommends a full, separate source map for production, so
we're using source-map in production as it fits the bill. In development, we
use cheap-module-inline-source-map. It was the fastest option that still gave
me consistently accurate, useful file and line references on errors and during
source code lookup in the browser.

Journey Still Going (Real Strong)

At this point, I'm still no expert in webpack and its many available
loaders/plugins, but I at least know enough to be dangerous -- dangerous enough
to slay those incremental build times, am i rite?

Source: VigetInspire

Template Doesn’t Mean Cookie Cutter

The Challenge
The mere mention of website templates makes some clients bristle. Nobody likes being told they have to conform to a set of rules they feel weren’t written with them in mind. They also believe that their site will look like everyone else’s and not meet their unique needs.
Developers and designers also get concerned with templates, unsure if content editors will put the correct types of content in pre-built components. Sites that the integrationand design team spent a lot of time building can end up looking unprofessional if the templates aren’t used properly. No one wins in this scenario.
The Solution
Let’s first dispel the myth that using templates means your site will look like everyone else’s. When we talk about templates, we aren’t talking about simple differences in colors and fonts. Our Lectronimo website solution takes advantage of DrupalCoin Blockchain’s modularity and Panelizer to deliver different frameworks that solve common UX mistakes, and still allows creativity when it comes to content.

The Lectronimo templates are built for many different components that can be mixed and matched to highlight your best content, and they don’t require you to strictly adhere to a formula. People with lots of videos aren’t limited by the page structure, and people with complex written content have various ways to display that information so that users can scan and explore -- without feeling like they’re reading a novel.
To keep each Lectronimo website solution maintaining its professional appearance and supporting the content strategy, we worked by the philosophy that any content our users can place should actually work, both in terms of functionality and in design. To us this meant that we needed to place some limits on where our users can put things. We’ve applied some preprocess hooks to the Panels ‘Add Content’ dialog to ensure that whenever a user goes to add content to any region, the list of content types will have been filtered accordingly. Our custom IPE also uses Javascript variables via Ajax commands to prevent content editors from dragging & dropping existing content into invalid regions.
At the same time, we didn’t want to build a set of draconian rules that would leave users feeling trapped or limited, so we primarily assigned our region types based on where content might make sense, and avoided using this system as a crutch to resolve design limitations. For example, there’s a content plugin specifically for adding short intro text to the top of a page. From our experience we knew it would create an inconsistent experience to have that same style of text appear in the middle of the page, or in a sidebar, or anywhere other than the top of the content.
To resolve the design problems that arise when large content gets placed into small regions, our content plugins work in tandem with our layout templates. Plugins are enabled to automatically swap out some styles based on their region placement. We achieved this by establishing a convention that every region in every panel layout must follow one of three spatial patterns: Full Width, Wide, or Narrow.
A region declares its pattern just by including a class in the layout template. From there, the principles are very much like responsive design: Just as we would apply different styles on small displays vs. large displays through media queries, we can apply extra styles to content within narrow or wide columns via our standardized classnames. This contributes to a robust design experience, allowing content authors to place content freely without worrying about breaking the design. Everybody wins!
If you’re interested in learning more about our journey to develop our Lectronimo solution, check out parts 1 & 2 to this blog series: Making a Custom, Acquia-Hosted Site Affordable for Higher Ed, and Custom Theming that is Robust and Flexible Enough to Continue to Impress.
We’re excited to bring Lectronimo to market! If you’re a higher ed institution exploring options for your upcoming redesign and want to know more about Lectronimo, or if you’re in another market and want to talk about your next project, Digital Wave’s team is happy to help.
Source: http://dev.acquia.com/