User experience design and interactive design

Latest Posts

Employ A Freelance Animator Services

Created making use of Specialist HD cam tools and also HD airborne camera systems, recording High Dynamic Array photos and Hd video clip footage, these easy as well as cost effective videos will elegantly advertise the highlights of your home or company. Promotional Video for InTuch. I have actually had the ability to on-board new staff members that can enter as well as develop incredible videos in minutes. The high quality of the videos and also the assistance are initial course. With us, you get lots of production top quality content for the cost of one clip elsewhere.

You found 1 club coupon video clip graphics & vector from $9. All from our worldwide neighborhood of visuals developers. Making use of marketing videos and movement graphics can be the start of a process to enlighten and also inform possible clients and also current users regarding your excellent product or services that they might not yet recognize with, yet which can make a difference to their work or lifestyle.

Developed utilizing Specialist HD cam tools and HD aerial camera systems, catching High Dynamic Array pictures and also High Definition video footage, these simple and inexpensive video clips will elegantly promote the highlights of your home or service.

With many frauds as well as spam floating around the web, there are many scenarios when individuals are disuaded from getting since they are uncertain of the character as well as credibility of the firm, although they have superb items.

Specifically with new products, including the rapid growing arena of applications, your company will certainly need to allow people learn about what you are using, assist them to value scenarios in which they can actually use the item as well as show how it will benefit them.

To show my colleagues in the firm this very good video (thanks Basse!), that mostly work on Windows XP:–LRB-(I sent them the link, but heard that they might not enjoy the video clip on WinAmp3 or on Windows media gamer (version 8).

 

We supply cost-free devices to produce expert introductions, animations, slide shows, promotions and also songs visualizations with no technological skills in mins. It was a brand-new branding and marketing effort that aimed to begin a conversation among customers concerning the myths bordering the crop security market by utilizing the power of laughter, courtesy of some slapstick comedy and a side of innuendos among farmers.

As a dj-producer and also indie document tag supervisor, I consider Renderforest as one of the most adequate tool to develop and also publish eye-catching music videos as well as punchy label promotion video clips in order to advertise my music and also my label.I truly delight in the innovative templates and the flexibility, the motivating music visualizers and also the wide option of sexy logo discloses.

The right videos triggering the best feelings can go a long way to show audiences that the actual organization is built of people who appreciate their areas and want to influence and also inspire each other to success. Our collaboration with CohnReznick is one instance of our company’s advertising videos for workers.

Below are 17 amazing explainer videos throughout a wide range of markets, media electrical outlets, and also magazines to jumpstart your own job. Use this vide theme to produce a company video promo for your advertising and marketing campaigns extremely easily.

305 Photography As Well As Video

We took our finest footage, a driving soundtrack and edgy motion graphics, then infused a dosage of powerful duplicate to make an effect on the world’s future wellness professionals. Our corporate video manufacturing services concentrate on developing first-class media that knocks your message objectives out of the park as well as leaves your target markets smiling as well as maybe even a little teary-eyed. Produce a collection of movement graphics for HD Exposure in Airlie Beach treat their video clip in Adobe Premier, colour grade and also add After Impacts movement graphics.

The complimentary intro templates enable you to make a computer animated video clip using a series of still photos, and these can be plugged into numerous setups on the display. Mobile app promotion is getting easy with us. Develop remarkable, sensible mobile application video clips and also tutorials to improve your mobile application marketing.

Instead of needing to have workers attend training workshops that cost your company time, money as well as productivity, a well designed training video clip can be made use of and also applied at any moment. In this video I reveal you my a method I make use of for promptly developing expert high quality movement visuals promo videos for my service and also my clients.

Video clip Templates developed by specialists. Company advertising video is also a terrific method to interact new procedures, programs or inner resources for staff members, plus provide a thumbs-up to individuals that are establishing your company’s standards as well as going above and beyond in their job.

With a company promotion, you can do a little immoral self-promotion, a party of what your company suggests, as well as a highlight of your team’s achievements to drive action. We cover nearly all these layouts with our video clip design templates, as well as because it is cost-free to create a test video with our online video clip maker, you can experiment every one of them without fee.

Take One generated this promo video that was created in motion graphics. Develop computer animated advertising and marketing videos for your organisation in no time at all with our ready to utilize layouts. This film was created to promote the shed in Torun’s old town as well as was made in behalf of Organization for the Promotion of Science CHUNK LLC.

Our on-line video clip software application is able to create videos with magnificent 3D graphics since we make use of Aspect 3D, a leading software program for 3D modelling and also computer animation. By teaming up with a go-to staff and also firm for business video clips– the LAI Video clip nerds.

Utilize our themes to make explainer computer animations, educational discussions and also whiteboard videos, services or product promotions and more. As well as creating the brief promotion video clip, we likewise produced over 3 hrs of initial material to play real-time at the place, synced in-time with the DJ’s set making use of VJ software application Resolume.

הדפסת תמונות על מגנטים

סטודיו לעיצוב גרפי

עיצוב פלייר לעסק

Practical Suggestions To Improve Usability Of Landing Pages With Animation From Slides

Practical Suggestions To Improve Usability Of Landing Pages With Animation From Slides

Practical Suggestions To Improve Usability Of Landing Pages With Animation From Slides

Nick Babich

(This is a sponsored post.) For a long time, UI animation was an afterthought for designers. Even today, many designers think of animation as something that brings delight but does not necessarily improve usability. If you share this point of view, then this article is for you. I will discuss how animation can improve the user experience of landing pages, and I’ll provide the best examples of animation created using the Slides framework.

The Slides framework is an easy-to-use tool for creating websites. It allows anyone to create a sleek landing page in a few minutes. All you need to do is choose an appropriate design from the list of predefined slides.

A collection of predefined designs in Slides.

Four Ways Animation Supports Usability Of Landing Pages

Landing page design is more than just about visual presentation; it’s about interaction. Details of interaction design make a fundamental difference on modern websites. And animated effects can reinforce interactions. To improve the usability of a landing page, an animation must be a functional element, not just decoration. It should serve a clear functional purpose. Below are a few common ways that animation can improve usability.

1. Create A Narrative

Every designer is a storyteller. When we create a website, we are telling a story to our visitors. And it’s possible to tell a much more engaging story by using animation.

Animation can help bring content to life. One good example of such animation can be found on Ikonet. The animation there keeps users engaged as they scroll the page and learn about the company.

Animation can also be used to call the visitor’s attention to something they should notice and act upon. For example, if you have an important text section or a call to action, sliding them in (instead of having them just appear) can help visitors understand where they should focus. Take a look at the Preston Zeller example below. The way elements appear on the pages drives the user’s focus to those areas. The great thing about this animation is that it draws attention to important information without being disruptive.

When visitors scroll on Preston Zeller, elements gradually appear on the page. As a result, attention is drawn to vital information.

2. Provide Feedback

Human-computer interaction is based on two fundamentals: user input and system feedback. All interactive objects should react to user input with appropriate visual or audio feedback.

Below you can see the Custom Checkbox effect created using the Slides framework. The subtle bouncing animation the user sees when they change the state of the toggle reinforces the feeling of interactivity.

With Slides, you can create nice hover animations and encourage users to interact with objects. Take a look at Berry Visual. When you hover the mouse on “Send Message” or on the hamburger menu in the top-right corner, a nice animated effect occurs. It creates a sense that these elements are interactive.

Buf Antwerp is another excellent example of how on-hover animated feedback can improve the user experience. When visitors hover over a tile, a semi-transparent overlay appears, and text provides additional information about the item.

3. Create Relationships

A great place to add animation to a landing page is at moments of change. All too often, moments of change are abrupt &mdahs; for example, when users click on a link, a new screen suddenly appears. Because sudden changes are hard for users to process, such changes usually result in a loss of context — the brain has to scan the new page to understand how the new context is connected to the previous one.

Consider this example of an abrupt change:

This abrupt change feels unnatural and leads to unnecessary brain work (the brain has to scan entire layout to understand what has just happened). (Image: Adrian Zumbrunnen via Smashing Magazine)

Compare that to the following example, in which a smooth animated transition guides the user to the different parts of the screen:

A simple animated transition maintains context, making it easy to understand what has changed about a screen. (Image: Adrian Zumbrunnen via Smashing Magazine)

It’s clear that in the second example, animation prevents abrupt change — it fills the gap and connects two stages. As a result, visitors understand that the two stages belong together. This principle applies equally when you have a parent-to-child relationship between two objects:

Animated transition between preview and details. (Image: Tympanus)

It also applies when you create a transition between stages. The smooth transitions between slides in the example below create a sense of sequence, rather than separate unrelated parts of the page.

Using animation, it’s possible to define object relationships and hierarchies when introducing new elements.

4. Making Boring Tasks Fun

It might be difficult to imagine how to introduce playful elements into everyday experiences. But by adding a bit of surprise where it’s most unexpected, we can turn a familiar interaction into something unexpected and, thus, memorable.

When you visit Tympanus’ 3D Room Exhibition, it looks like any other gallery website that you’ve visited before. But your impression of the website changes immediately once you interact with a page. As you move the cursor, the page moves, and this effect creates a sense of 3D space. This feeling is reinforced when you go from one page to another; it looks like you’re traveling from one room to another within a 3D space.

Large preview

Now let’s talk about something much more familiar than 3D effects: web forms. Who loves filling out forms? Probably nobody. Still, filling out forms is one of the most common tasks on the web. And it is possible to turn this dull activity into a fun exercise. Take a look Darin Senneff’s Yeti character, which is used in a form. When the user starts typing their password, the mascot covers its eyes. Such an animated effect brings a lot of delight when you see it for the first time.

The Yeti character responds to user input.

Last but not least, it’s possible to make the scrolling experience not just more visually interesting, but also helpful for readers. Below is Storytelling Map, an interactive journey in which a path along a map is animated according to the content being scrolled through on the page. The idea ties the text, visuals and locations together; visitors read the information and see it in the context of the map).

Large preview

Six Best Practices For Landing Page Animation

Identifying the places where animation has utility is only half the story. Designers also need to implement animation properly. In this section, we’ll find out how to animate like a pro.

1. Don’t Animate Several Elements At Once

When a few objects are animated simultaneously, it becomes distracting for users. Because the human brain and eye are hardwired to pay attention to moving objects, the user’s focus will jump from one element to another, and the brain will need extra time to figure out what just happened (especially if the movement happens very quickly). Thus, it’s important to schedule animations properly.

It’s vital to understand the concept of transition choreography: the coordinated sequence of motions that maintain the visitor’s focus as the interface changes. Minimize the number of elements that move independently; only a few things should happen at the same time (typically, no more than two or three). Thus, if you want to move more than three objects, group some objects together and transform them as a single unit, rather than animating them independently.

Don’t animate everything at the same time. It will make the objects compete for attention and divide focus. (Image: Google)

Slides offers an excellent benefit to web designers: It prevents them from overusing motion in design. Each animated effect available in Slides has been carefully designed to deliver content in the best possible way.

2. Animation Shouldn’t Conflict With Landing Page’s Personality

Each time you add animation to a design, you introduce personality. This personality will largely depend on the animated effect you choose to use.

When people interact with a product, they have certain expectations. Imagine designing a landing page for a banking service, and you decide to use a bouncing animation to introduce a form that collects the user’s personal information. Many users will hesitate to provide their details because the form conflicts with their expectations.

An example of bouncing animation. Avoid bouncing animation in forms that collect bank account details. Users might hesitate to provide their data. (Image: Joel Besada)

The Slides framework allows you to choose from 10 animated styles, such as Stack, Zen, Film, Cards and Zoom. Experiment with different effects, and choose what’s best for your case.

Large preview

3. Watch The Time

When it comes to designing animation, timing is everything. The timing of your animation can mean the difference between a good interaction and a bad one. When working on animation, you’ll usually spend a third of your time finding the right animated effects and the other two thirds finding the right timing to make the animation feel smooth.

Generally, keep the animation short. Animation should never get in the way of the user completing a task, because even the most beautifully executed animation would be really annoying if it slows down users. The optimal speed for a UI animation is between 200 and 500 milliseconds. An animation that lasts less than 1 second is considered as instant, whereas an animation longer than 5 seconds can convey a feeling of delay.

When it comes to creating an animated effect, one parameter has a direct impact on how the animation is perceived: easing, or timing function in CSS terms. Easing helps designers make movement more natural.

The Slides framework enables web designers to customize easing. You’ll find easing along with other effects in the section “Effect Settings”.

Large preview

4. Think About Accessibility

Animation is a double-edged sword. It can improve usability for one group of users, while causing problems for another group. Apple’s release of iOS 7 was a recent example of the latter. iOS 7 was full of animated effects, and shortly after its release, iPhone users reported that the animated transitions were making them feel dizzy.

Your responsibility as a designer is to think about how people with visual disorders will interact with your design. Check the WCAG’s guidelines on animation, and be sure that your design aligns with them. Track whether a user wants to minimize the amount of animation or motion. A special CSS media feature, “prefers-reduced-motion“, detects whether the user has requested that the system minimize the amount of animation or motion used. When it is set to “reduce”, then it’s better to minimize the amount of movement and animation (for example, by removing all non-essential movement).

Also, conduct usability testing to check that users will all abilities, including people with visual disorders, won’t have any problem interacting with your design.

5. Prototype And Test Your Design Decisions

Animation is fun to play with. It’s easy to go overboard and end up with a design that overwhelms users with too much motion. Unfortunately, there is no silver bullet for great animation; it’s hard to set clear criteria of what is “just enough”. Be ready to spend time on prototyping, testing and optimizing animated effects.

Here are a few tips worth taking into account during testing:

  • Test on different hardware.
    Many hardware factors can drastically affect animation performance: screen size, screen density, GPU performance, to name just a few. As a result, a user on a high-definition screen might have a completely different experience than a user on an older screen. Consider such factors when designing animation to prevent performance bottlenecks. Don’t blame slow hardware; optimize your animation to work great on all sort of devices.
  • Test on mobile.
    Most websites are built and tested on a desktop; the mobile experience and animation performance is often treated as an afterthought. Lack of testing on mobile could cause a lot of problems for mobile users, because some animated techniques work great on desktop but not as well on mobile. To avoid a negative experience, confirm that your design works fine on both desktop and mobile. Test on mobile early and often.
  • Watch animation at a slow speed.
    It might be hard to notice problems when an animation (especially a complex one) runs at full speed. When you slow the animation down (say, at one tenth the speed), such issues become evident. You can also record slow-motion video of your animations and show them to other people to get other perspectives.

With the Slides framework, you can create a high-fidelity interactive prototype in minutes. You can use a WYSIWYG editor to create animated effects, publish the design, and see how it works on both desktop and mobile devices.

6. Animation Shouldn’t Be An Afterthought

There’s a reason why so many designers think of animation as an unnecessary feature that overloads the user interface and makes it more complicated. In most cases, that’s true when designers introduce animation at the end of the design process, as lipstick for the design — in other words, animation for the sake of animation. Random motion without any purpose won’t benefit visitors much, and it can easily distract and annoy.

To make meaningful animation, take time at the beginning of the project to think about areas where animation would naturally fit. Only in this way will animation be natural to the user flow.

Conclusion

Good functional animation makes a landing page not just more appealing, but also more usable. When done correctly, animation can turn a landing page from a sequence of sections into a carefully choreographed, memorable experience. The Slides framework helps web designers use animation to communicate clearly.

Smashing Editorial(ms, ra, al, yk, il)
(Visited 1 times, 1 visits today)

Getting Started With Gutenberg By Creating Your Own Block

Getting Started With Gutenberg By Creating Your Own Block

Getting Started With Gutenberg By Creating Your Own Block

Muhammad Muhsin

WordPress is the most popular Content Management System (CMS) by far —powering more than 30% of the web. It has undergone a huge metamorphosis during its 15 years of existence. Its latest addition is Gutenberg which is to be released in version 5.0.

Named after Johannes Gutenberg (the inventor of the printing press), Gutenberg is going to fundamentally change WordPress, further helping reach its goal to democratize publishing.

WordPress usually releases its major features as a plugin to test the waters before baking them into the core. Gutenberg is no exception. In this article, we will learn how to go about building your first Gutenberg block. We will be building a Testimonials Slider Block while dwelling on the basics of Gutenberg.

Here is an outline for this article:

  1. Installing The Gutenberg Plugin
  2. Installing The Testimonials Slider Block
  3. Getting Started With The Configuration
  4. Registering A Block
  5. Introducing Gutenberg Specific Syntax
  6. The attributes Object
  7. The edit And save Functions
  8. Continuing Development
  9. Starting A New Gutenberg Block
  10. Conclusion

This article assumes the following:

  • Some knowledge of WordPress such as how content is saved and basic plugin development;
  • Basic understanding of React and ES6;
  • Knowledge of both npm and webpack.

Recommended reading: The Complete Anatomy Of The Gutenberg WordPress Editor

Installing The Gutenberg Plugin

If you are a WordPress user, just go ahead and install the Gutenberg plugin from the WordPress.org plugin repository. This is what one should use in a production site.

However, if you’re developing a Gutenberg block, I recommend that you clone the development version of Gutenberg which is hosted at GitHub. For help with setting up a local environment, please read the contribution guide.

You get the latest development version of Gutenberg this way but the primary reason to do this is to be able to use the development version of React.js that comes bundled with Gutenberg. The development version has more verbose error reporting which helps greatly with debugging.

Now when you go and create a page or a post, you will be able to edit using the Gutenberg Editor.


Gutenberg Editor Demo
Gutenberg Editor Demo (Large preview)

Since this article is about creating a Gutenberg Block, we will not go into the introduction to the Editor, For a complete understanding of what is Gutenberg and how to use it, please refer to Manish Dudharejia’s article on Smashing Magazine.

Installing The Testimonials Slider Block

The plugin in question — the one we are going to go through is already published to the WordPress repository.

Please install the Testimonials Slider Block plugin to your local WordPress instance so that you have a feel for how the plugin works.

You can also fork or clone the project from GitHub.

After activating the plugin, you can go to your Gutenberg Editor and add a Testimonials Slider to your content:


Testimonials Slider Block
Selecting the Testimonials Slider Block (Large preview)

Adding content to the Testimonials Slider Block
Adding content to the Testimonials Slider Block (Large preview)

Testimonials Slider Block in the frontend
Testimonials Slider Block in the frontend (Large preview)

Now I will go through how I built the plugin and how you too can build a similar one. To keep the article concise, I will not share the entire code in here. However, after reading this you should be able to create your own Gutenberg block.

Getting Started With The Configuration

A Gutenberg block is generally created as part of a plugin. Our plugin is not going to be any different.

Navigate to the plugins directory in your local WordPress instance. Move to the testimonials-slider-block. Notice the following files and folders:

  1. gutenberg-testimonials-slider.php is the main file which has details of the plugin, such as name, description, author details and license. These details will be used in the plugin description in the Plugins menu in the dashboard. You will see that this file calls the init.php file.
  2. The init.php file enqueues the different JavaScript and CSS files. This includes both the external libraries like Bootstrap and Font Awesome and our build files.
  3. The .babelrc file instructs webpack what kind of JavaScript files we are writing.
  4. The package.json file contains all the npm modules that are used in the plugin. You will use the npm install command to install all those packages.
  5. webpack.config.js file contains the configuration for webpack to build our JavaScript and CSS. if you did not know, webpack is a package bundler mainly used for bundling our JavaScript modules and putting them into one file that is then enqueued by WordPress.

That was a lot of configuration files. Now we can go about actually building our Gutenberg block.

Registering A Block

Within the src folder you will see the index.js file. This is the fle that webpack looks for, to bundle the JavaScript. You can see that this file imports the slider.js file within the block folder.

The block folder has the following styles:

  • slider.js: contains the actual code for the block
  • editor.scss: the styles file describing the block within the Gutenberg Editor
  • style.scss: contains styles pertaining to how the block is displayed in the frontend.

Please open the slider.js file in your editor.

This file first imports both the editor and style scss files. Then it imports internationalization component, registerBlockType and the MediaUpload and PlainText components. The last two components will be used to upload the author image and to take in the different text inputs to save in the database.

Next you will see how a block is registered.

It takes in a name as the first parameter. The name must be prefixed with a namespace specific to your plugin in order to avoid any conflicts with another block with the same name.

The second parameter is an array with the following properties and functions:

  • Title
    The name of the block which will appear when you add a new block in the Gutenberg Editor.
  • Icon
    The block’s icon which will be picked up from dashicons. You can also specify your own SVG icons if you want to.
  • Category
    Under which category of blocks will the block appear. Some of the categories are: common, formatting, layout widgets and embed.
  • Keywords
    An array of strings that describe the block, similar to tags.
  • Attributes
    A JavaScript object which contains a description of the data that is saved by the block.
  • Edit
    The function that provides an interface for the block within the Gutenberg Editor.
  • Save
    The function that describes how the block will be rendered in the frontend.

To learn more, please refer to this documentation.

Introducing Gutenberg Specific Syntax

Gutenberg is built with React and the blocks that we build for Gutenberg use a similar syntax.

It certainly helps to know a bit of React to build custom Gutenberg blocks though you don’t have to be an expert.

The following things are useful to know before starting the block development:

  • The HTML class is replaced with className like in React.
  • The edit and save methods return JSX, which stands for JavaScript XML. If you are wondering, JSX is syntax exactly like HTML, except you can use HTML tags and other components like PlainText and RichText within it.
  • The setAttributes method works similar to React’s setState. What it does is, when you call setAttributes the data in the block is updated and the block within the editor is refreshed.
  • The block uses props in the edit and save functions, just like React. The props object contains the attributes object, the setAttributes function and a ton of other data.

The attributes Object

The attributes object that was mentioned previously define the data within the Gutenberg block. The WordPress Gutenberg Handbook says:

Attribute sources are used to define the strategy by which block attribute values are extracted from saved post content. They provide a mechanism to map from the saved markup to a JavaScript representation of a block.

Each source accepts an optional selector as the first argument. If a selector is specified, the source behavior will be run against the corresponding element(s) contained within the block. Otherwise, it will be run against the block’s root node.

For more details on how to use attributes, please refer to this guide.

The following is the attributes object that is used in the Testimonials Slider Block:

attributes: {
   id: {
     source: "attribute",
     selector: ".carousel.slide",
     attribute: "id"
   },
   testimonials: {
     source: "query",
     default: [],
     selector: "blockquote.testimonial",
     query: {
       image: {
         source: "attribute",
         selector: "img",
         attribute: "src"
       },
       index: {
         source: "text",
         selector: "span.testimonial-index"
       },
       content: {
         source: "text",
         selector: "span.testimonial-text"
       },
       author: {
         source: "text",
         selector: "span.testimonial-author span"
       },
       link: {
         source: "text",
         selector: ".testimonial-author-link"
       }
     }
   }
 },

The source tells Gutenberg where to look for data within the markup.

Use attribute to extract the value of an attribute from markup, such as the src from img element. The selector and attribute tell what element to look for and what exact attribute to pick the data from respectively. Notice that the selector string picks up an HTML element from the save function.

Use text to extract the inner text from markup and html to extract the inner HTML from markup.

Use query to extract an array of values from markup. Entries of the array are determined by the selector argument, where each matched element within the block will have an entry structured corresponding to the query argument, an object of attribute and text sources.

You can access the attributes in the edit and save functions through props.attributes.

When you use console.log(props.attributes.testimonials) in the edit function, you get the following result:

  (2) [{...}, {...}]
    ▼0:
      author:"Muhammad"
      content: "This is a testimonial"
      image: "http://localhost/react-gutenberg/wp-content/uploads/2018/08/0.jpg"
      index: 0
      link: "https://twitter.com/muhsinlk"
    ▶__proto__: Object
  ▼1:
    author: "Matt"
    content: "This is another testimonial"
    image: "http://localhost/react-gutenberg/wp-content/uploads/2018/08/767fc115a1b989744c755db47feb60.jpeg"
    index: 1
    link: "https://twitter.com/photomatt"
   ▶__proto__: Object
   length: 2
  ▶__proto__: Array (0)

Therefore, in the above code, id is a text that uniquely describes each testimonial block whereas testimonials is an array of objects where each object has the properties as shown in the above screenshot.

The edit And save Functions

As mentioned above, these two functions describe how the block is rendered in the editor as well as in the frontend respectively.

Please read the full description here.

The edit Function

If you look at the edit function, you will notice the following:

  1. I first get the props.attributes.testimonials array to a const variable. Notice the ES6 Object Destructuring to set the const value.
  2. Then generate an id for the block which will be used to make each block unique when you add more than one Testimonials Slider Block to your content.
  3. Then the testimonialsList is generated, which is got from sorting then mapping the testimonials array that we got in step 1.
  4. Then, the return function gives out JSX, which we discussed earlier. The testimonialsList, which we constructed in step 3 is rendered. The + button is also rendered, pressing which will create a new testimonial inside the block.

If you dig into testimonialsList, you will see that it contains the PlainText and MediaUpload components. These provide the interface for entering the different texts and uploading the author image respectively.

The PlainText component looks like this:

 {
  const newObject = Object.assign({}, testimonial, {
    content: content
  });
  props.setAttributes({
    testimonials: [
      ...testimonials.filter(
        item => item.index != testimonial.index
      ),
      newObject
    ]
    });
  }}
/>
</code></pre>
<p>The attributes I have used for the <code>PlainText</code> component are:</p>
<ul>
<li><code>className</code><br />The CSS class of the component in order to style it.</li>
<li><code>style</code><br />To give a minimum height so that the content does not look like a one-line text. Specifying the height using the class selector did not work.</li>
<li><code>placeholder</code><br />The text that will be displayed when no content is added.</li>
<li><code>value</code><br />The value of the component from the object within the testimonials array.</li>
<li><code>autoFocus</code><br />To tell the browser to focus on this component (input field) as soon as the user adds a new testimonial by clicking the + button.</li>
<li><code>onChange</code><br />What looks like the most complex attribute in this list. This function first gets a copy of the current testimonial and assigns the changed content to newObject. Then it spreads the array of objects, filters out the current object using index and then replaces the newObject within the array. This is set using the the props.setAttributes function to the testimonials array.</li>
</ul>
<h4>The <code>save</code> Function</h4>
<p>This function does the following:</p>
<ol>
<li>I first get the <code>props.attributes.testimonials</code> array and <code>props.attributes.id</code> string to const variables. Again, notice the ES6 Object Destructuring being used to set the values for the two const variables id and testimonials.</li>
<li>Then I create the <code>carouselIndicators</code> variable, which is essentially JSX constructed from the testimonials array.</li>
<li>Then the <code>testimonialsList</code> is created from the testimonials array. The snippet below is from the mapped function callback return.
<pre class="break-out"><code class="language-css">{testimonial.content && (
  <p className="testimonial-text-container">
    <i className="fa fa-quote-left pull-left" aria-hidden="true" />
    <span className="testimonial-text">{testimonial.content}</span>
    <i class="fa fa-quote-right pull-right" aria-hidden="true" />
  </p>
)}
</code></pre>
<p>Notice the conditional rendering. The markup will not be rendered for content if the content is not set.</li>
<li>Next, if the testimonials array has objects within it, the HTML is rendered. This is what will be serialized and saved to the database, and this is what will be shown in the frontend (not verbatim).</li>
</ol>
<h3 id="continuing-development">Continuing Development</h3>
<p>I’m sure you want to tinker around this plugin and see what happens. You can continue developing the plugin:</p>
<ol>
<li>Open up the terminal</li>
<li>Navigate to the plugin’s root directory</li>
<li><code>npm install</code></li>
<li><code>npm start</code></li>
</ol>
<p>This will install all the packages, build the files and watch for changes. Every time you make a change to the files, webpack will rebuild the JS and CSS files.</p>
<p><strong>Please note:</strong> Markup changes to the blocks will mess up the block in the Gutenberg Editor if you had added it before. Don’t be alarmed — you simply have to remove the block and add it again.</p>
<p>If you are done with developing you can <code>npm run build</code> to minify the files to make it ready for production!</p>
<p>Hopefully, you are now convinced Gutenberg block development is more approachable than it sounds.</p>
<p>I have the following plans in mind for this plugin:</p>
<ul>
<li>Allow users to select color of text, background and accent.</li>
<li>Allow users to select the size of slider and font.</li>
<li>Avoid depending on libraries like Bootstrap and Font Awesome.</li>
</ul>
<p>I encourage you <a href="https://github.com/laccadive-io/testimonials-slider-block">to make a pull request</a> with your improvements and extra features.</p>
<h3 id="starting-a-new-gutenberg-block">Starting A New Gutenberg Block</h3>
<p>There are many ways to develop a Gutenberg block. One of the recommended ways is to use <code><a href="https://github.com/ahmadawais/create-guten-block">create-guten-block</a></code> created by <a href="https://twitter.com/mrahmadawais">Ahmad Awais</a>. In fact, this project was built based on <code><a href="https://github.com/laccadive-io/guten-testimonial-block">guten-testimonial-block</a></code> which was bootstrapped from <code>create-guten-block</code>.</p>
<p>You can also check out <a href="https://github.com/zgordon/gutenberg-course">Zac Gordon’s repository</a> where he shows how to use the different Gutenberg components in your new block.</p>
<h3 id="conclusion">Conclusion</h3>
<p>We covered the following in today’s article:</p>
<ul>
<li>Installing and using Gutenberg and Testimonials Slider Block plugins</li>
<li>Configuration for a typical Gutenberg block plugin</li>
<li>Registering a Gutenberg block</li>
<li>How to use the attributes object</li>
<li>The <code>edit</code> and <code>save</code> functions and how to use them.</li>
</ul>
<p>I hope this article was useful for you. I can’t wait to see what you will build with and for Gutenberg!</p>
<div class="signature">
  <img src="https://www.smashingmagazine.com/images/logo/logo--red.png" alt="Smashing Editorial" /><span>(dm, ra, yk, il)</span>
</div>
</article>
</div>
<div class="tptn_counter" id="tptn_counter_59">(Visited 2 times, 1 visits today)</div>
						</div><!-- .entry-content -->
					</div><!-- wp-show-posts-inner --><div class="wpsp-clear"></div></article><article class=" wp-show-posts-single wpsp-clearfix post-58 post type-post status-publish format-standard hentry category-blogging" itemtype="http://schema.org/CreativeWork" itemscope><div class="wp-show-posts-inner" style="">						<header class="wp-show-posts-entry-header">
							<h2 class="wp-show-posts-entry-title" itemprop="headline"><a href="http://www.brandonwardracing.com/blogging/smashingconf-toronto-videos/" rel="bookmark">SmashingConf Toronto Videos</a></h2>						</header><!-- .entry-header -->
											<div class="wp-show-posts-entry-content" itemprop="text">
							<div>
<p>              <meta charset="utf-8"><link rel="canonical" href="https://www.smashingmagazine.com/2018/10/smashingconf-toronto-videos/"><title>SmashingConf Toronto Videos</title></p>
<article>
<header>
<h1>SmashingConf Toronto Videos</h1>
<address>The Smashing Editorial</address>
<p>                  <time datetime="2018-10-05T18:00:35+02:00" class="op-published">2018-10-05T18:00:35+02:00</time><time datetime="2018-10-09T16:43:59+00:00" class="op-modified">2018-10-09T16:43:59+00:00</time></header>
<p>This year, many of your favorite speakers were featured at our conference in Toronto, however, things were quite different this time. The speakers had been asked to present without slides. Yep, and it was brilliant!</p>
<p>In this pairing of videos from <a href="https://smashingconf.com/toronto-2018/">SmashingConf Toronto</a>, discover sketching with Eva-Lotta Lamm and SVG Animation with Sarah Drasner, but if you fancy watching all of them then head on over to our <a href="https://vimeo.com/album/5451191">SmashingConf Vimeo channel</a> anytime.</p>
<h3 id="how-i-think-when-i-think-visually-eva-lotta-lamm">How I Think When I Think Visually: Eva-Lotta Lamm</h3>
<p>Sketching is something which lends itself perfectly to the no-slides format. In this talk, Eva-Lotta demonstrates her process for visual thinking. A method which helps her order her thoughts, create sketchnotes, and visualize processes such as user journeys.</p>
<figure class="video-container"><iframe data-src="https://player.vimeo.com/video/292461456" width="600" height="480" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe></figure>
<h3 id="svg-and-vue-together-from-start-to-finish-sarah-drasner">SVG And Vue Together From Start To Finish: Sarah Drasner</h3>
<p>In this talk, Sarah starts with only an Illustrator document and by the end, makes it move! In this talk, which has an included GitHub repository to help you follow along, Sarah uses animation and Vue.js to create the final piece.</p>
<figure class="video-container"><iframe data-src="https://player.vimeo.com/video/292473138" width="600" height="480" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen></iframe></figure>
<p>Enjoyed watching these talks? There are many <a href="https://vimeo.com/album/5451191">more videos from SmashingConf Toronto</a> on Vimeo. We’re also getting ready for the upcoming <a href="https://smashingconf.com/">SmashingConf in New York</a> — see you there? 😉</p>
<div class="signature">
  <img src="https://www.smashingmagazine.com/images/logo/logo--red.png" alt="Smashing Editorial" /><span>(ra, il)</span>
</div>
</article>
</div>
<div class="tptn_counter" id="tptn_counter_58">(Visited 2 times, 1 visits today)</div>
						</div><!-- .entry-content -->
					</div><!-- wp-show-posts-inner --><div class="wpsp-clear"></div></article><article class=" wp-show-posts-single wpsp-clearfix post-57 post type-post status-publish format-standard hentry category-blogging" itemtype="http://schema.org/CreativeWork" itemscope><div class="wp-show-posts-inner" style="">						<header class="wp-show-posts-entry-header">
							<h2 class="wp-show-posts-entry-title" itemprop="headline"><a href="http://www.brandonwardracing.com/blogging/taming-this-in-javascript-with-bind-operator/" rel="bookmark"><div>Taming <code>this</code> In JavaScript With Bind Operator</div></a></h2>						</header><!-- .entry-header -->
											<div class="wp-show-posts-entry-content" itemprop="text">
							<div>
<p>              <meta charset="utf-8"><link rel="canonical" href="https://www.smashingmagazine.com/2018/10/taming-this-javascript-bind-operator/"><title>Taming <code>this</code> In JavaScript With Bind Operator</title></p>
<article>
<header>
<h1>Taming <code>this</code> In JavaScript With Bind Operator</h1>
<address>Willian Martins</address>
<p>                  <time datetime="2018-10-05T14:20:22+02:00" class="op-published">2018-10-05T14:20:22+02:00</time><time datetime="2018-10-09T16:43:59+00:00" class="op-modified">2018-10-09T16:43:59+00:00</time></header>
<p>Do you want to discover the next exciting JavaScript features that you didn’t even know you needed? In this article, I will introduce one of these proposals that if accepted may change the way you write code the same way the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax">spread operator</a> did.</p>
<p>However, here’s a small disclaimer: <strong>This feature is under development and discussion</strong>. The goal here is to add some hype around it and create awareness of the hard work that TC39 is doing to find consensus, fix all the syntax and semantics issues and have it shipped with the next releases of ECMAScript. If you have any concerns, comments or desire to express your support, please go to the <a href="https://github.com/tc39/proposals">TC39 proposals repository</a>, add a star to this feature to show your support, open an issue to voice your concerns and get involved.</p>
<p>But before, I want to ask a simple (but tricky) question:</p>
<p>What <em>is</em> <code>this</code>?</p>
<p>In ECMAScript, <code>this</code> has a different semantic than <code>this</code> in many other programming languages, where <code>this</code> often refers to the lexical scope. In general, this behaves differently in the global scope, within a function, in non-strict mode and strict mode. Let’s break this behavior down into small examples.</p>
<aside class="product-panel product-panel__tilted product-panel--book" data-audience="non-subscriber">
<div class="container product-panel--book__container">
<div class="panel__description panel__description--book">
<p>Getting workflow <em>just</em> right ain’t an easy task. So are proper estimates. Or alignment among different departments. That’s why we’ve set up <strong>“this-is-how-I-work”-sessions</strong> — with smart cookies sharing what works well for them. A part of the <a href="https://smashed.by/workflowpanelmembership">Smashing Membership</a>, of course.</p>
<p>      <a href="https://smashed.by/workflowpanelmembership" class="btn btn--green btn--large"><br />
        Explore Smashing Membership ↬<br />
      </a>
      </div>
<div class="panel__image panel__image--book">
        <a href="https://smashed.by/workflowpanelmembership" class="books__book__image"></p>
<div class="books__book__img">
          <img src="https://www.smashingmagazine.com/images/smashing-cat/smashing-tv-box-cat.svg" alt="Smashing TV, with live sessions for professional designers and developers." width="310" height="400" /></div>
<p>      </a>
      </div>
</p></div>
</aside>
<h3><code>this</code> In The Global Scope</h3>
<p>What is the value of <code>this</code> in this example?</p>
<pre><code class="language-javascript">console.info(this);</code></pre>
<p>At the global scope, <code>this</code> refers to the global object, like the <strong>window</strong> in the browser, <strong>self</strong> on web workers and the <strong>module.exports</strong> object in NodeJS.</p>
<h3><code>this</code> In The Function Scope</h3>
<p>At the function scope, <code>this</code> behaves depending on how the function is called, and this aspect makes it tricky to predict its value. We can understand it better by checking the following examples:</p>
<h4>What Is The Value Of <code>this</code> Here?</h4>
<pre><code class="language-javascript">function foo() {
  return this;
}

console.info(this);
</code></pre>
<p>Inside a function, <code>this</code> starts to have an interesting behavior since its value depends on how the function is called. In the example above, <code>this</code> still refers to the global scope, with one difference. In NodeJs, this will point to the global object instead of <code>module.exports</code>.</p>
<h4>Setting A Value Into <code>this</code>:</h4>
<pre><code class="language-javascript">function foo() {
  this.bar = 'baz';
  return this;
}

console.info(foo());
console.info(new foo());
</code></pre>
<p>Setting a value into <code>this</code> sets the value into the current context. The example above logs the global scope with the property <code>bar</code> with the value <code>baz</code> in the first <code>console.info</code>, but it logs only <code>{ bar: ‘baz’ }</code> in the second <code>console.info</code>. It happens because the <code>new</code> operator among other things bounds the value of <code>this</code> to the newly created object.</p>
<h3>This Keyword In The Strict Mode</h3>
<p>In strict mode, the <code>this</code> variable doesn’t carry the value of the context implicitly, this means if its context isn’t set, the value of this is default to <code>undefined</code> as shown in the following snippet.</p>
<pre><code class="language-javascript">function foo() {
  "use strict";
  return this;
}

console.info(foo()); //undefined
</code></pre>
<p>To set the context of <code>this</code> in strict mode you can set the function as member of an object, use <code>new</code> operator, <code>Function.prototype.call()</code>, <code>Function.prototype.apply()</code> or <code>Function.prototype.bind()</code> methods for example.</p>
<pre><code class="language-javascript">function foo() {
  "use strict";
  return this;
}

var a = { foo };

foo(); // undefined
a.foo(); // { foo: ƒunction }
new foo(); // Object foo {}
foo.call(this); // Window / Global Object
foo.apply(this); // Window / Global Object
foo.bind(this)(); // Window / Global Object
</code></pre>
<h3>Making <code>this</code> Variable Predictable</h3>
<p>At this point, you may realize that the value of <code>this</code> in ECMAScript is quite tricky to predict. To demonstrate the available techniques to make it predictable, I’d like to present the following example that mimics a common use case of <code>this</code>.</p>
<pre><code class="language-javascript"><button id="button">🐱 🐾</button>
<script>
  class MeowctComponent {
    constructor() {
      this.paw = document.getElementById('button');
    }

    meow() {
      console.info('🐱 on this: ', this.paw);
    }
  }

  const cat = new MeowctComponent();
  cat.paw.addEventListener('click', cat.meow);
</script>
</code></pre>
<p>In the example above, I created a <code>MeowctComponent</code>, which has only one property <code>paw</code> that points to the button element and one method called <code>meow</code> that should print the paw instance property into the console.</p>
<p>The tricky part is that the meow method is executed only when the button is clicked, and because of that, <code>this</code> has the button tag as context, and since the button tag does not have any paw property, it logs the <strong>undefined</strong> value into the console. Tricky, isn’t it?</p>
<p>To fix this specific behavior we can leverage on the <code>Function.prototype.bind()</code> method to explicitly bind this to the cat instance, like in the following example:</p>
<pre><code class="language-javascript"><button id="button">Meow</button>
<script>
  class MeowctComponent {
    constructor() {
      this.paw = document.getElementById('button');
    }

    meow() {
      console.info('🐱 on this: ', this.paw);
    }
  }

  const cat = new MeowctComponent();
  cat.paw.addEventListener('click', cat.meow.bind(cat));
</script>
</code></pre>
<p>The method <code>.bind()</code> returns a new permanently bound function to the first given parameter, which is the context. Now, because we bound the <code>cat.meow</code> method to the <code>cat</code> instance, <code>this.paw</code> inside the meow method correctly points to the <em>button element</em>.</p>
<p>As an alternative to the <code>Function.prototype.bind()</code> method, we can use the arrow function to achieve the same result. It keeps the value of the lexical <code>this</code> of the surrounding context and dispenses the need to bind the context explicitly, like in the next example:</p>
<pre><code class="language-javascript"><button id="button">🐱 Meow</button>
<script>
  class MeowctComponent {
    constructor() {
      this.paw = document.getElementById('button');
    }

    meow() {
      console.info('🐱 on this: ', this.paw);
    }
  }

  const cat = new MeowctComponent();
  cat.paw.addEventListener('click', () => cat.meow());
</script>
</code></pre>
<p>Although arrow functions solve the majority of use cases where we need to bind the lexical <code>this</code> explicitly, we still have two use cases for which the use of the explicit bind is needed.</p>
<h4>Calling A Known Function Using <code>this</code> To Provide Context:</h4>
<pre><code class="language-javascript">let hasOwnProp = Object.prototype.hasOwnProperty;
let obj = Object.create(null);

obj.hasOwnProperty('x') // Type Error...

hasOwnProp.call(obj, "x"); //false

obj.x = 100;

hasOwnProp.call(obj, "x"); // true
</code></pre>
<p>Let&#8217;s suppose for any reason we have this <code>obj</code> object that doesn&#8217;t extend <code>Object.prototype</code> but we need to check if <code>obj</code> has an <code>x</code> property by using the <code>hasOwnProperty</code> method from <code>Object.prototype</code>. To achieve that, we have to use the call method and explicitly pass <code>obj</code> as the first parameter to make it work as expected, which appears not to be so idiomatic.</p>
<div class="sponsors__wide-place"></div>
<h4>Extracting A Method</h4>
<p>The second case can be spotted when we need to extract a method from an object like in our <code>MeowctComponent</code> example:</p>
<pre><code class="language-javascript"><button id="button">🐱 🐾</button>
<script>
  class MeowctComponent {
    constructor() {
      this.paw = document.getElementById('button');
    }

    meow() {
      console.info('🐱 on this: ', this.paw);
    }
  }

  const cat = new MeowctComponent();
  cat.paw.addEventListener('click', cat.meow.bind(cat));
</script>
</code></pre>
<p>These use cases are the baseline problem that the bind operator tries to solve.</p>
<h3>The Bind Operator <code>::</code></h3>
<p>The <strong>Bind operator</strong> consists of an introduction of a new operator <code>::</code> (double colon), which acts as syntax sugar for the previous two use cases. It comes in two formats: <strong>binary</strong> and <strong>unary</strong>.</p>
<p>In its binary form, the bind operator creates a function with its left side is bound to <code>this</code> of the right side, like in the following example:</p>
<pre><code class="language-javascript">let hasOwnProp = Object.prototype.hasOwnProperty;
let obj = Object.create(null);

obj.hasOwnProperty('x') // Type Error...

obj::hasOwnProp("x"); //false

obj.x = 100;

obj::hasOwnProp("x"); // true
</code></pre>
<p>That looks more natural, doesn’t it?</p>
<p>In its unary form, the operator creates a function bound to the base of the provided reference as a value for <code>this</code> variable, like in the following example:</p>
<pre><code class="language-javascript">...
cat.paw.addEventListener('click', ::cat.meow);
// which desugars to
cat.paw.addEventListener('click', cat.meow.bind(cat));
...
</code></pre>
<p>What’s so cool about the bind operator is the fact that it opens up new opportunities for creating virtual methods, as in this example of lib for iterable.</p>
<pre><code class="language-javascript">import { map, takeWhile, forEach } from "iterlib";

getPlayers()
  ::map(x => x.character())
  ::takeWhile(x => x.strength > 100)
  ::forEach(x => console.log(x));
</code></pre>
<p>It’s super useful because the developer doesn’t need to download the whole lib to do small stuff, which reduces the amount of imported JavaScript. Besides, it makes those kinds of libs easier to extend.</p>
<h3>How To Develop Using Bind Operator</h3>
<p>To keep the example simple, let’s suppose we need to create a math module which the developer can chain the operations to form an math expression that, given a number as an entry it could make all calculations into a pipeline. The code to achieve this is simple and could be written as the following.</p>
<pre><code class="language-javascript">function plus(x) {
  return this + x;
}

function minus(x) {
  return this - x;
}

function times(x) {
  return this * x;
}

function div(x) {
  return this / x;
}
</code></pre>
<p>As you can spot in the example above, we expect to have the value as a context and we use this to make the calculation, so then using the bind operator, we could make an expression like the following:</p>
<pre><code class="language-javascript">1::plus(2)::times(4)::div(3)::minus(1); // returns 3
</code></pre>
<p>Which is equivalent to:</p>
<pre><code class="language-javascript">minus.call(div.call(times.call(plus.call(1, 2), 4), 3), 1);
</code></pre>
<p>The first snippet looks more idiomatic, isn’t?</p>
<p>Going a little further, we can use it to convert a temperature from Celsius to Fahrenheit, this can be accomplished by the following function expression:</p>
<pre><code class="language-javascript">const toFahrenheit = x => x::times(9)::div(5)::plus(32);
console.info(toFahrenheit(20)); // 68
</code></pre>
<p>So far, we demonstrate how create functions to interact with the values, but what about extending the object with virtual methods? We can do new stream compositions mixing built-in methods with custom ones. To demonstrate it, we can compose string methods with custom ones. First, let&#8217;s check the module with the custom methods with its implementation.</p>
<pre><code class="language-javascript">function capitalize() {
  return this.replace(/(?:^|s)S/g, a => a.toUpperCase());
}

function doubleSay() {
  return `${this} ${this}`;
}

function exclamation() {
  return `${this}!`;
}
</code></pre>
<p>With this module in place we can do cool things like the following:</p>
<pre><code class="language-javascript">const { trim, padEnd } = String.prototype;

console.info(
  '   hello world   '
    ::trim()
    ::capitalize()
    ::doubleSay()
    ::exclamation()
    ::padEnd(30)
);

// "Hello World Hello World!      "
</code></pre>
<p>In the example above, you can spot that I extracted two methods from the <code>String.prototype</code>, <code>trim()</code> and <code>padEnd()</code>. Since these methods are extracted, I can use them to compose my stream of methods alongside with my virtual methods <code>capitalize()</code>, <code>doubleSay()</code> and <code>exclamation()</code>. This aspect is what makes bind operator so exciting and promising.</p>
<div class="sponsors__wide-place"></div>
<h3>Advantages And Disadvantages Of Bind Operator</h3>
<p>As you may realize at this point, there are some aspects that Bind Operator shines. Those are the following:</p>
<ul>
<li>It covers the only two missing use cases that explicit bind is necessary;</li>
<li>It makes easy to make <code>this</code> variable to be predictable;</li>
<li>It adds a new way to extend functionality by using virtual methods;</li>
<li>It helps to extend built-in objects without extending the prototype chain. Do you remember <a href="https://developers.google.com/web/updates/2018/03/smooshgate">Smoosh Gate</a>?</li>
</ul>
<p>In the other side, to compose functions with bind operator you need to rely on this to be bound, that can lead to some issues like in this example:</p>
<pre><code class="language-javascript">const plus = (x) => this + x;

console.info(1::plus(1));
// "[object Window]1"
</code></pre>
<p>As it becomes clear in the example above, it’s not possible to compose arrow function with bind operator, since it’s not possible to bind <code>this</code> to an arrow function. Sometimes users don’t want to rely on <code>this</code> to be bound to compose their behavior through a function chain, which could be a problem if you only use bind operator to achieve this.</p>
<p>Another issue that is often said is the possible syntax overload that the bind operator can bring which can be a problem to onboard newcomers to the language. Realizing that a specific operator works in binary and unary form is tricky as well. One possible solution for this is to introduce the binary form to the language separately of the unary form. So once the binary form is integrated to the language, the committee can reassess if the unary form is still necessary. Meanwhile, users can get used to the binary form, and the syntax overload could potentially be mitigated.</p>
<h3>Conclusion</h3>
<p>Predict the value of <code>this</code> in JavaScript is trick. The language has some rules to explain how the context is assigned to this, but in the daily basis we want to make this value predictable. The <code>Function.prototype.bind()</code> method and arrow functions help us to make the value of <code>this</code> predictable. The <strong>bind operator</strong> comes to play to cover the two use cases that we still need to explicitly bind <code>this</code>.</p>
<p>The advent of bind operator opens an opportunity to create a new set of function composition via virtual methods, but it can add a syntax overload making difficult to onboard newcomers to the language.</p>
<p>The author of the bind operator is Kevin Smith, and <a href="https://github.com/tc39/proposal-bind-operator">this proposal is in Stage 0</a>. The TC39 is open to feedback. If you like this feature and think that it’s useful, please add a star in the repository, if you have an Idea to solve the issues presented here, if you have another way to shape the syntax or semantics of this features or if you spot another issue with it, please open an issue in the repo and share your thoughts/ideas with the committee.</p>
<div class="signature">
  <img src="https://www.smashingmagazine.com/images/logo/logo--red.png" alt="Smashing Editorial" /><span>(dm, ra, yk, il)</span>
</div>
</article>
</div>
<div class="tptn_counter" id="tptn_counter_57">(Visited 2 times, 1 visits today)</div>
						</div><!-- .entry-content -->
					</div><!-- wp-show-posts-inner --><div class="wpsp-clear"></div></article><article class=" wp-show-posts-single wpsp-clearfix post-56 post type-post status-publish format-standard hentry category-blogging" itemtype="http://schema.org/CreativeWork" itemscope><div class="wp-show-posts-inner" style="">						<header class="wp-show-posts-entry-header">
							<h2 class="wp-show-posts-entry-title" itemprop="headline"><a href="http://www.brandonwardracing.com/blogging/use-cases-for-flexbox/" rel="bookmark">Use Cases For Flexbox</a></h2>						</header><!-- .entry-header -->
											<div class="wp-show-posts-entry-content" itemprop="text">
							<div>
<p>              <meta charset="utf-8"><link rel="canonical" href="https://www.smashingmagazine.com/2018/10/flexbox-use-cases/"><title>Use Cases For Flexbox</title></p>
<article>
<header>
<h1>Use Cases For Flexbox</h1>
<address>Rachel Andrew</address>
<p>                  <time datetime="2018-10-04T13:50:30+02:00" class="op-published">2018-10-04T13:50:30+02:00</time><time datetime="2018-10-09T16:43:59+00:00" class="op-modified">2018-10-09T16:43:59+00:00</time></header>
<p>We come to the final part in my Flexbox series here at Smashing Magazine. In this post, I am going to spend some time thinking about what the use cases for Flexbox really are, given that we now have CSS Grid Layout, giving some suggestions for what you might use when and a way to decide.</p>
<h3 id="earlier-in-this-series">Earlier In This Series</h3>
<p>If you haven’t picked up the other articles yet, this is essentially a concluding post so check those out first. I began by describing <a href="https://www.smashingmagazine.com/2018/08/flexbox-display-flex-container/">exactly what happens when you create a flex container</a>. In the second article in the series, I took a look at <a href="https://www.smashingmagazine.com/2018/08/flexbox-alignment/">alignment</a>, and how we align items on the main and cross axis in flexbox. In the third article, I unpack <a href="https://www.smashingmagazine.com/2018/09/flexbox-sizing-flexible-box/">how sizing works in Flexbox</a>, and how the browser figures out how big a flex item should be. Now that we know exactly how Flexbox works, we can wrap up by thinking about the use cases it is best for.</p>
<h3 id="should-i-use-grid-or-flexbox">Should I Use Grid Or Flexbox?</h3>
<p>This is still the top question that I’m asked when teaching layout, and in general, I find that as people become more used to working with newer layout methods, it becomes a question you need to ask yourself less. As you build more components you will get a feel for which layout method to use.</p>
<p>If you are just getting to grips with the idea, however, the thing to remember is that <strong>both CSS Grid Layout and Flexbox are both CSS</strong>. Whether you have specified <code>display: grid</code> or <code>display: flex</code>, you often use more that is common than is different. Both Grid and Flexbox use the properties which are part of the Box Alignment specification; they both draw on concepts detailed in CSS Intrinsic and Extrinsic Sizing.</p>
<p>Asking whether your design should use Grid <em>or</em> Flexbox is a bit like asking if your design should use font-size <em>or</em> color. You should probably use both, as required. And, no-one is going to come to chase you if you use the <em>wrong</em> one.</p>
<aside class="product-panel product-panel__tilted product-panel--book" data-audience="non-subscriber">
<div class="container product-panel--book__container">
<div class="panel__description panel__description--book">
<p>Meet <a href="https://smashingconf.com/ny-2018/">SmashingConf New York <span class="small-caps">2018</span></a> (Oct <span class="small-caps">23–24</span>), focused on <em>real</em> challenges and <strong>real front-end solutions</strong> in the <em>real</em> world. From progressive web apps, Webpack and HTTP/2 to serverless, Vue.js and Nuxt — all the way to <strong>inclusive design</strong>, branding and machine learning. With Sarah Drasner, Sara Soueidan and <a href="https://smashed.by/confpanelspeakers">many other speakers</a>.</p>
<p>    <a href="https://smashed.by/confpanelspeakers" class="btn btn--green btn--large"><br />
      Check all topics and speakers ↬<br />
    </a>
      </div>
<div class="panel__image panel__image--book">
<p>  <a href="https://www.smashingconf.com/ny-2018/" class="books__book__image"></p>
<div class="books__book__img">
          <img src="https://www.smashingmagazine.com/images/smashing-cat/cat-scubadiving-panel.svg" alt="Smashing TV, with live sessions for professional designers and developers." width="310" height="400" /></div>
<p>      </a>
      </div>
</p></div>
</aside>
<p>So, we are not picking between Vue.js and React, Bootstrap or Foundation. We are using CSS to do layout, and we need to use the bits of CSS which make most sense for the particular bit of our design that we are working on. Consider each component, and decide what is best for it, or what combination of things are best for it.</p>
<p>That might be Grid, or it might be Flexbox. It might be a grid outer container with some of your grid items becoming flex items or the reverse. There is no issue in nesting a grid inside a flex item if that is what your design calls for.</p>
<h3 id="what-is-flexbox-really-for">What Is Flexbox Really For?</h3>
<p>The Flexbox specification describes the layout method like this,</p>
<blockquote><p>“Flex layout is superficially similar to block layout. It lacks many of the more complex text- or document-centric properties that can be used in block layout, such as floats and columns. In return, it gains simple and powerful tools for distributing space and aligning content in ways that web apps and complex web pages often need.”</p></blockquote>
<p>I think the key phrase here is “distributing space and aligning content”. Flexbox is all about taking a bunch of things (which have varying sizes) and fitting them into a container (which itself has a varying size). Flexbox is squishy. Flexbox tries to create the best possible layout for our items, giving bigger items more space and smaller items less space, thus preserving readability of content.</p>
<p>When people find Flexbox hard and weird, it is often because they are trying to use Flexbox as a grid system — trying to take back control over sizing and space distribution. When you do this, Flexbox can seem weird and hard as you are fighting against the very thing that makes it Flexbox, i.e. that inherent flexibility.</p>
<p>Therefore, patterns which suit flex layout very well are those where we are not so interested in having a pixel-perfect size for each item. We just want those items to display well alongside each other.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="EdPjgE" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/EdPjgE">Smashing Flexbox Series 4: Items Sharing Space</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>There are also patterns where you want to have wrapped lines, however, you do not want a strict grid. If we take the seminal grid versus the Flexbox example where we use the repeat auto-fill syntax in grid, and then a flex container with wrapped flex lines. Here we immediately see the difference between the two methods.</p>
<div class="sponsors__wide-place"></div>
<p>In the grid example, the grid items line up in rows and columns. While the number of column tracks changes (depending on space), the items always go into the next grid cell that is available. In fact, there is no way to ask a grid item to span tracks if there are some empty cells to fill in that auto-flow scenario.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="LgGVyX" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/LgGVyX">Smashing Flexbox Series 4: Grid Example</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>In the flex example, the final items share any space left over between them; this way, we do not have alignment horizontally and vertically.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="vVLOZq" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/vVLOZq">Smashing Flexbox Series 4: Wrapped Items flex-basis: auto</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>If we have a flex-basis of auto and any of the flex items are larger, they will also be given more space so that the alignment could be quite different line by line.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="JmGdEa" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/JmGdEa">Smashing Flexbox Series 4: Wrapped Items</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>This then is a very clear example of where we would want to use Flexbox over Grid Layout. If we want the items to wrap but to take up the space they need on a line-by-line basis. That is a very different kind of layout to a grid. Patterns like this might be a set of tags (one or two-word elements that you wish to display nicely as a set of items), taking up the space they need and not rigidly being forced into a strict grid.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="EdPVNz" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/EdPVNz">Smashing Flexbox Series 4: Tags example</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>At the present time, Flexbox is also the best way to perform vertical and horizontal centering of an item inside a container.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="BqjoxY" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/BqjoxY">Smashing Flexbox Series 4: Center an Item</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>In the future (when there is browser support for the Box Alignment properties outside of flex layout), we may be able to do this without needing to add <code>display: flex</code> to the container. For now, however, that is what you need to do — that extra line of CSS is really not an issue.</p>
<p>Flexbox is very good at dealing with small, one-dimensional components. Sets of form fields, icons, or other information can be easily laid out and allowed to be flexible without needing to carefully set the sizing on each item.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="vVLNbZ" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/vVLNbZ">Smashing Flexbox Series 4: Simple Row of Form Elements</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>You might also choose Flexbox in a scenario where all you need to do is cause content at the bottom of a layout to stick to the bottom of a container rather than popping up. In this example, I make the container a flex container by displaying the contents as a column, then allowing the middle to grow by pushing the footer to the bottom of the component.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="xyZYwY" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/xyZYwY">Smashing Flexbox Series 4: Sticky Footer Card</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>In production, I am finding that Flexbox is useful for lots of little jobs, making sure that things align properly, that space is shared out nicely between items. You could absolutely use a one-dimensional grid container for some of those things, and don’t worry about it if that is what you decide to do.</p>
<p>What I think Flexbox does very well, however, is to cope with the situation where extra items might need to be added that I didn’t expect in my design. For example, if I have a navigation component using Grid I would be creating enough tracks for all items, as I wouldn’t want a new row to be created if I had “too many” items. With flexbox, as long as I was allowing the items to be flexible from a flex-basis of 0 (or auto) then the items would allow their new companion into the row and make space for it.</p>
<div class="sponsors__wide-place"></div>
<h3 id="when-should-i-not-use-flexbox">When Should I <em>Not</em> Use Flexbox?</h3>
<p>We have looked at some of the reasons that I think you should choose Flexbox over Grid Layout, so we can now look at some of the places where Flexbox might not be the best choice. We have already looked at our Flexbox versus grid example with items aligned horizontally and vertically versus items which take up space line by line. And, that distinction is the first thing to consider.</p>
<p>The grid example is of two-dimensional layout. Layout in rows and columns at the same time. The Flexbox example is one-dimensional layout. We have wrapped flex lines but space distribution is happening on a line by line basis. Each line is essentially acting as a new flex container in the flex-direction.</p>
<p>Therefore, if your component needs two-dimensional layout, you would be better placed to use Grid over Flexbox. It doesn’t matter whether your component is large or small. If you take one thing from this article, it is to remove the idea from your brain that Grid is somehow only meant for main page layout, and Flexbox for components. You can have a tiny component that requires two-dimensional layout, and main page structures which better suit one-dimensional layout.</p>
<p>Another good point at which Grid may be considered the better solution is if you are applying a width, or a flex-basis set as a length unit to your flex items in order to line them up with another row of flex items, or just to restrict the flexibility in some way. Quite often that indicates either than you really need a two-dimensional layout method or that the control from the container of grid would suit your layout better.</p>
<p>For example, we could make our flex layout display more like a grid, by restricting the flexibility of our items. Setting flex-grow to 0 and sizing the items with percentages, in a similar way to the way we would size items in a floated “grid”. If you find that you are doing that, I would suggest that Grid Layout is a much better approach as it is designed for this type of layout.</p>
<p data-height="500" data-theme-id="light" data-slug-hash="jeWZyM" data-user="rachelandrew" data-default-tab="result" class="codepen">See the Pen <a href="https://codepen.io/rachelandrew/pen/jeWZyM">Smashing Flexbox Series 4: Wrapped Flex Items with Percentage Widths</a> by Rachel Andrew (<a href="https://codepen.io/rachelandrew">@rachelandrew</a>) on <a href="https://codepen.io/">CodePen</a>.</p>
<p>With all that said, remember that there is very often not a clear right <em>or</em> wrong answer. Sometimes the only thing you can do is to try different ways and see what suits the component best. Remember that you can also switch layout methods, using Flexbox at one breakpoint and Grid at another.</p>
<h3 id="and-that-s-a-flex-wrap">And That’s A (Flex) Wrap!</h3>
<p>I hope this series on Flexbox has been helpful and demonstrated how understanding some of the logic behind alignment and sizing of flex items, makes life easier when working with it. If you are left with any outstanding questions or have a pattern which seems not to have an obvious answer in terms of the layout method to use, post a comment.</p>
<div class="signature">
  <img src="https://www.smashingmagazine.com/images/logo/logo--red.png" alt="Smashing Editorial" /><span>(il)</span>
</div>
</article>
</div>
<div class="tptn_counter" id="tptn_counter_56">(Visited 2 times, 1 visits today)</div>
						</div><!-- .entry-content -->
					</div><!-- wp-show-posts-inner --><div class="wpsp-clear"></div></article></section><!-- .wp-show-posts --><div class="wpsp-load-more"><span aria-current='page' class='page-numbers current'>1</span>
<a class='page-numbers' href='http://www.brandonwardracing.com/page/2/'>2</a>
<a class="next page-numbers" href="http://www.brandonwardracing.com/page/2/">Next &rarr;</a></div>		</div>
				</div>
						</div>
			</div>
		</div>
				<div data-id="cd292da" class="elementor-element elementor-element-cd292da elementor-column elementor-col-50 elementor-top-column" data-element_type="column">
			<div class="elementor-column-wrap elementor-element-populated">
					<div class="elementor-widget-wrap">
				<div data-id="0656825" class="elementor-element elementor-element-0656825 elementor-widget elementor-widget-sidebar" data-element_type="sidebar.default">
				<div class="elementor-widget-container">
			<section id="categories-2" class="widget widget_categories"><h2 class="widget-title">Categories</h2>		<ul>
	<li class="cat-item cat-item-2"><a href="http://www.brandonwardracing.com/category/blogging/" >Blogging</a>
</li>
	<li class="cat-item cat-item-8"><a href="http://www.brandonwardracing.com/category/browser/" >Browser</a>
</li>
	<li class="cat-item cat-item-11"><a href="http://www.brandonwardracing.com/category/design/" >Design</a>
</li>
	<li class="cat-item cat-item-9"><a href="http://www.brandonwardracing.com/category/graphics/" >Graphics</a>
</li>
	<li class="cat-item cat-item-10"><a href="http://www.brandonwardracing.com/category/languages/" >Languages</a>
</li>
	<li class="cat-item cat-item-4"><a href="http://www.brandonwardracing.com/category/layout/" >Layout</a>
</li>
	<li class="cat-item cat-item-3"><a href="http://www.brandonwardracing.com/category/markup/" >Markup</a>
</li>
	<li class="cat-item cat-item-7"><a href="http://www.brandonwardracing.com/category/technologies/" >Technologies</a>
</li>
	<li class="cat-item cat-item-6"><a href="http://www.brandonwardracing.com/category/tools/" >Tools</a>
</li>
	<li class="cat-item cat-item-5"><a href="http://www.brandonwardracing.com/category/typography/" >Typography</a>
</li>
		</ul>
</section><section id="recent-posts-widget-with-thumbnails-2" class="widget recent-posts-widget-with-thumbnails"><div id="rpwwt-recent-posts-widget-with-thumbnails-2" class="rpwwt-widget">
	<h2 class="widget-title">Recent Posts</h2>	<ul>
			<li><a href="http://www.brandonwardracing.com/blogging/practical-suggestions-to-improve-usability-of-landing-pages-with-animation-from-slides/"><span class="rpwwt-post-title">Practical Suggestions To Improve Usability Of Landing Pages With Animation From Slides</span></a></li>
			<li><a href="http://www.brandonwardracing.com/blogging/getting-started-with-gutenberg-by-creating-your-own-block/"><span class="rpwwt-post-title">Getting Started With Gutenberg By Creating Your Own Block</span></a></li>
			<li><a href="http://www.brandonwardracing.com/blogging/smashingconf-toronto-videos/"><span class="rpwwt-post-title">SmashingConf Toronto Videos</span></a></li>
			<li><a href="http://www.brandonwardracing.com/blogging/taming-this-in-javascript-with-bind-operator/"><span class="rpwwt-post-title"><div>Taming <code>this</code> In JavaScript With Bind Operator</div></span></a></li>
			<li><a href="http://www.brandonwardracing.com/blogging/use-cases-for-flexbox/"><span class="rpwwt-post-title">Use Cases For Flexbox</span></a></li>
		</ul>
</div><!-- .rpwwt-widget -->
</section><section id="widget_tptn_pop-2" class="widget tptn_posts_list_widget"><h2 class="widget-title">Popular Posts</h2><div class="tptn_posts  tptn_posts_widget tptn_posts_widget2"><ul><li><a href="http://www.brandonwardracing.com/markup/web-design/"     class="tptn_link"><img src="http://brandonwardracing.com/wp-content/uploads/2018/09/featured-web-design.jpg" alt="Web design" title="Web design" width="300" height="300" class="tptn_thumb tptn_firstcorrect" /></a></li><li><a href="http://www.brandonwardracing.com/blogging/use-cases-for-flexbox/"     class="tptn_link"><img src="https://www.smashingmagazine.com/images/smashing-cat/cat-scubadiving-panel.svg" alt="Use Cases For Flexbox" title="Use Cases For Flexbox" width="300" height="300" class="tptn_thumb tptn_firstcorrect" /></a></li><li><a href="http://www.brandonwardracing.com/blogging/taming-this-in-javascript-with-bind-operator/"     class="tptn_link"><img src="https://www.smashingmagazine.com/images/smashing-cat/smashing-tv-box-cat.svg" alt="&lt;div&gt;Taming &lt;code&gt;this&lt;/code&gt; In JavaScript With Bind Operator&lt;/div&gt;" title="&lt;div&gt;Taming &lt;code&gt;this&lt;/code&gt; In JavaScript With Bind Operator&lt;/div&gt;" width="300" height="300" class="tptn_thumb tptn_firstcorrect" /></a></li><li><a href="http://www.brandonwardracing.com/blogging/smashingconf-toronto-videos/"     class="tptn_link"><img src="https://www.smashingmagazine.com/images/logo/logo--red.png" alt="SmashingConf Toronto Videos" title="SmashingConf Toronto Videos" width="300" height="300" class="tptn_thumb tptn_firstcorrect" /></a></li><li><a href="http://www.brandonwardracing.com/blogging/getting-started-with-gutenberg-by-creating-your-own-block/"     class="tptn_link"><img src="https://www.smashingmagazine.com/images/smashing-cat/cat-rollerderby.svg" alt="Getting Started With Gutenberg By Creating Your Own Block" title="Getting Started With Gutenberg By Creating Your Own Block" width="300" height="300" class="tptn_thumb tptn_firstcorrect" /></a></li></ul><div class="tptn_clear"></div></div></section><section id="do-etfw-2" class="widget widget-do-etfw">					<h2 class="widget-title">Follow us on Twitter</h2>		
		<a class="twitter-timeline" data-width="300" data-height="400" data-tweet-limit="5" data-theme="light" data-link-color="#3b94d9" data-border-color="#f5f5f5" href="https://twitter.com/webdesign">Tweets by @webdesign</a>
</section>		</div>
				</div>
						</div>
			</div>
		</div>
						</div>
			</div>
		</section>
						</div>
			</div>
		</div>
		<div class="tptn_counter" id="tptn_counter_12">(Visited 40 times, 1 visits today)</div>
  <footer id="colophon" class="site-footer">
    <div class="site-info clearfix">
        
        <div class="site-info-copyright ">
          <a href="https://wordpress.org/">Proudly powered by WordPress</a>
          <span class="sep"> | </span>
          Theme: Doo by <a href="http://themevs.com/">ThemeVS</a>.        </div>
    </div><!-- .site-info -->
  </footer><!-- #colophon -->

  <div id="back_top"><i class="fa fa-angle-up"></i></div>

</div><!-- #page -->
</div>
<script type='text/javascript'>
/* <![CDATA[ */
var wpcf7 = {"apiSettings":{"root":"http:\/\/www.brandonwardracing.com\/wp-json\/contact-form-7\/v1","namespace":"contact-form-7\/v1"},"recaptcha":{"messages":{"empty":"Please verify that you are not a robot."}},"cached":"1"};
/* ]]> */
</script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/plugins/contact-form-7/includes/js/scripts.js?ver=5.0.4'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/plugins/simple-share-buttons-adder/js/ssba.js?ver=4.9.8'></script>
<script type='text/javascript'>
Main.boot( [] );
</script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/themes/doo/assets/bootstrap/js/bootstrap.min.js?ver=3.3.7'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/themes/doo/assets/js/ie10-viewport-bug-workaround.js?ver=1.3.16'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/themes/doo/assets/js/theme.js?ver=1.0.34'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/plugins/easy-twitter-feed-widget/js/twitter-widgets.js?ver=1.0'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-includes/js/wp-embed.min.js?ver=4.9.8'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-includes/js/jquery/ui/position.min.js?ver=1.11.4'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/plugins/elementor/assets/lib/dialog/dialog.min.js?ver=4.5.0'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/plugins/elementor/assets/lib/waypoints/waypoints.min.js?ver=4.0.2'></script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/plugins/elementor/assets/lib/swiper/swiper.jquery.min.js?ver=4.4.3'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var elementorFrontendConfig = {"isEditMode":"","is_rtl":"","breakpoints":{"xs":0,"sm":480,"md":768,"lg":1025,"xl":1440,"xxl":1600},"version":"2.2.5","urls":{"assets":"http:\/\/www.brandonwardracing.com\/wp-content\/plugins\/elementor\/assets\/"},"settings":{"page":[],"general":{"elementor_global_image_lightbox":"yes","elementor_enable_lightbox_in_editor":"yes"}},"post":{"id":12,"title":"Home","excerpt":""}};
/* ]]> */
</script>
<script type='text/javascript' src='http://www.brandonwardracing.com/wp-content/plugins/elementor/assets/js/frontend.min.js?ver=2.2.5'></script>

</body>
</html>