Your website visitors are visual beings (with the exception of robots). When they see the awesome content, product, video, or all of the other cool things they discover on there, they will share it. Now how great would it be if that wasn’t just a plain link in the message, post, comment or tweet but a quick preview of your awesome stuff?

Meta tags enable search engines, social networks and messenging services get the required information from your website and display it in a visual way instead of just a plain old link. This will not only make your website better, but can also result in higher engagement, since the users have more context on what to expect when visiting the link.

Update: Check out headless-devtools, a library for automating DevTools actions from code by leveraging the DevTools Protocol

Chrome DevTools is thego-toanalysistool for understanding what's going on under-the-covers of your app and conducting perf-audits. As you are interacting with the site like a real user would, you can use DevTools to drill-down to every tiny detail about the page. This is great for manual analysis. But if your goal is to monitor web performance over time, you might find that tools in that space are not as powerful. Automated synthetic monitoring services don't expose nearly as much information as there is in DevTools, and for the most part the only type of user interaction they emulate is waiting for the page to load.

If you are not an Ecma member, any non-trivial contributions require signing a legal agreement with Ecma. See the section "Required Legal Agreements" below for details.

For small changes to ECMAScript, you can contribute by filing an issue or a pull request against the current text of ECMA-262 standard in this repository.

To file an issue, go to the ecma262 issues page. From there, examine in the existing issues to see if an issue already exists to track this issue. If so, add a comment to the existing issue; otherwise, file a new issue documenting the problem.

In my previous article, I've shown how to smoothly transition from one state to another using vanilla JavaScript. Make sure you check that one out first because I'll be referencing some things I explained there in a lot of detail, like demos given as examples, formulas for various timing functions or how not to reverse the timing function when going back from the final state of a transition to the initial one.

The last example showcased making the shape of a mouth to go from sad to glad by changing the d attribute of the path we used to draw this mouth.

Manipulating the path data can be taken to the next level to give us more interesting results, like a star morphing into a heart.

React is now one of the most popular JavaScript UI libraries in the world. It has over 70K stars on GitHub, over 1100 contributors, over 6M downloads this past month alone, and well over 4K company stacks. But when Facebook first introduced React to the world, not too many people cared.

For the latest episode of Stack Stories, we did something a bit different. We decided to focus on the origin story of the one of the most popular technologies in the software development world:

Last, but definitely not least, you should pay attention to the general-purpose array transformation that is Array.prototype.reduce(). .reduce() is slightly different from all the other methods mentioned above, as it uses a higher-order function as its argument, as well as an accumulator. This might sound a little bit confusing at first, so an example should help you grasp the basic idea behind .reduce():

The above example should not be particularly confusing to anyone who has ever had to sum the values of an array. We first define a reusable higher-order function that we use to sum the values of each array. Then, we actually use this function to sum the values of the first array and then, using the already accumulated value of the first array’s sum as our starting value, we feed this sum to the second array summation function, so that all values in the second array will be added to that, instead of zero.

As web developers, there’s no escaping the fact that we have typed HTML since we did our first web development tutorial or published our first website. Right now, we can manipulate HTML to our own whim, creating beautiful and interactive websites with CSS and Javascript out of XML structured documents. Tutorials on how to use libraries and the next hottest frameworks crop up here and there on how to manipulate HTML to create ever more exciting sites for users to interact with.

But we might have forgotten the true purpose and magic of HTML. HTML is a parse-able document that is the main place for content. And this content is, for all its intents and purposes, is both readable by computers and all kinds of users. Baked into its tags are little helpers for users.

Last week, Adobe announced that they would stop supporting Flash by 2020. In some ways this is surprising: I still sometimes run into pages that require Flash, and you can still find a few defenders of the platform in the software development community.

But in other ways it was a long time coming. You can often see the decline of a technology in advance, by examining data on its usage in the software development community. One notable source of such data is in our Stack Overflow Trends tool, which shows questions about Flash have been declining in frequency since 2010.

This sudden shift in Flash’s fortune suggests there’s truth to the conventional wisdom that Apple “killed” Flash by not supporting it on the iPad in 2010.

There’s a quote by Tim Berners-Lee, Director of W3C and inventor of the World Wide Web, that says, “The power of the web is in its universality”. As people who make a living by making websites, it’s our responsibility to ensure everyone has access to them. Web accessibility seems like a tall order on paper, but it’s definitely much easier than it sounds.

Our ten web accessibility guidelines are designed to ensure that all websites are universal.

This will not only help screen reader users, but will also improve browsing experience for slow connections. We’ve sorted our guidelines by implementation time to give you a clear picture of just how much effort you’ll have to put into this process. Before you get overwhelmed, take our word for it—

I've used JavaScript loaders for years; whether it was the Dojo loader, curl.js, or even using jQuery as a JavaScript loader, it's incredibly useful to request a set of resources and react once they've completed loading. Each JavaScript loader is feature-packed, efficient, and does a wonderful job of shimming the Promise API which didn't exist in the browser when the loader is created. The following is not that type of loader.

This super simple loader allows for loading of image, CSS, and JavaScript files, using the Promise API, and fires a callback upon success or failure. This tiny "loader" (I shouldn't even call it that) does

Modularity, reusability, and scalability are not only coding concepts but you can also make use of them to create better-optimized design systems. Atomic design is a new methodology for building effective UIs from the bottom up, using a chemistry analogy.

Instead of designing collections of web pages, atomic design starts with the simplest UI components called atoms (buttons, menu items, etc.), and builds the whole UI up via four more stages: molecules, organisms, templates, and pages.

The methodology was created by designer Brad Frost with the aim of “crafting successful UI design systems”. Atomic design was

In Angular 2, we are used to listening for events on the Component’s DOM elements, however how do we listen to events outside of this range?

Two ways to do this:

Creating a Host Listener

Using the Component’s host property

The Host Listener Way

Angular 2 provides a HostListener Decorator in order to match an event triggered on a target with a function declared on the next line. Just like this:

The syntax is as follow: ‘target:event’, [args]. When clicking on the document, we will be able to use the event triggered, you can also pass other arguments like $event.target for example. However the target must be

In the sections below we will take a closer look at some of the differences between Marko and React.

Both Marko and React JSX allow HTML markup and JavaScript to be combined into a single file and both support building web applications based on UI components. Marko utilizes an HTML-JS syntax while most React apps use the JSX syntax.

React JSX makes JavaScript more like HTML and Marko makes HTML more like JavaScript.

In the end, both Marko and React allow JavaScript and HTML to be intertwined.

In React JSX, all attribute values are parsed as string values unless {} is used.

With Marko, all attribute values are parsed as JavaScript expressions. The following Marko code is equivalent to the React JSX code above:

As users, we easily get frustrated by the buffering videos, the images that take seconds to load, pages that got stuck because the content is being loaded. Loading the resources from some cache is much faster than fetching the same from the originating server. It reduces latency, speeds up the loading of resources, decreases the load on server, cuts down the bandwidth costs etc.

Introduction

What is web cache? It is something that sits somewhere between the client and the server, continuously looking at the requests and their responses, looking for any responses that can be cached. So that there is less time consumed when the same request is made again.

TL;DR: In this article, we'll explore managing state with an immutable data store in an Angular application using ngrx/store: reactive Redux for Angular. We'll also authenticate our app with Auth0 and implement route authorization with route guards. The final code can be cloned from this GitHub repository.

Managing State in Angular Apps

State management in large, complex applications has been a headache plaguing AngularJS / Angular developers over the last few years. In AngularJS (version 1.x), state management is often addressed using a confusing mixture of services, events, and $rootScope. In

Social media is one of the dominant forms of interactions on the Internet. Leading platforms such as Facebook and Twitter count hundreds of millions of users each month. In this article, I will show you how social media is a rich vein of data for user researchers. I will argue that it would be an oversight for an organization to treat social media as nothing more than an opportunity for customer service enquiries, help requests and brand advocacy.

In the commercial sector, social media is a source of data about users that often gets ignored in favor of other more controlled user research activities, such as interviews and user testing. (Though, it is often used to recruit participants for these traditional methods.) Conversely, in the academic world, social media was immediately recognized as an interesting primary source of data. But it has been typically addressed with quantitative research methods, such as visualizing information flows between network members and graphing peaks of activity, which are not so relevant in most typical user research projects.