Several proposals expand the existing JavaScript class syntax with new functionality. This article explains the new public class fields syntax in V8 v7.2 and Chrome 72, as well as the upcoming private class fields syntax.

Here’s a code example that creates an instance of a class named IncreasingCounter:

Static site builders like Jekyll and Middleman offer a modern development environment (e.g. live editing, SASS, Webpack, etc), but are difficult to share with folks who would like a dashboard to edit content.

Vapid takes the best of static site builders and introduces the ability to have a dashboard with almost no extra effort.

TL;DR: Plug 'N Play is a good idea. .pnp.js is a bad idea. .pnp.json would be a better idea.

To preface this, I think Plug 'N Play is a great idea. My concerns come from the dependency analysis side. My day job is building analysis tools at FOSSA, and I've worked with a lot of package managers while building the FOSSA CLI.

.pnp.js is much harder to analyse than node_modules

There should be a method to access the Plug 'n Play API in a language-agnostic way without requiring a Node.JS runtime.

At FOSSA, we do dependency analysis in a variety of environments. We need to provide results reliably across these environments, including environments where Node.JS is not available. This use case is surprisingly common for us:

The original goal of the article was to show how data can help in improving the user-perceived page load performance by using predictive analytics[3]. The artifacts from the article were executable node modules which can be used for predictive pre-fetching & data-driven clustering of JavaScript chunks.

In the meantime, I talked to Addy Osmani who turned out to be exploring data-driven approach for predictive

In this blog post, I describe the pros and cons of three programming languages/dialects: JavaScript, TypeScript and ReasonML. My descriptions are based on recent experiences with TypeScript and ReasonML on a few smaller real-world projects and on years of experience with JavaScript.

Before we take a look at the languages, let’s first consider the pros and cons of static typing, given that TypeScript and ReasonML are statically typed and JavaScript isn’t.

The pros and cons of static typing

Pros:

Documentation: For most code, I find it very helpful if the types of parameters are documented. Then I know what to expect as a caller and as a callee.

A couple months ago, I was traveling outside of the U.S. and wanted to show a friend a link on my personal (static) site. I tried navigating to my website, but it took much longer than I anticipated. There’s absolutely nothing dynamic about it — it has animations and some responsive design, but the content always stays the same. I was pretty appalled at the results, ~4s to DOMContentLoaded, and 6.8s for a full page load. There were 20 requests for a static site, with 1mb of total data transferred. I was accustomed to my 1Gb/s, low latency internet in Los Angeles connecting to my server in San Francisco, which made this monstrosity seem lightning fast. In Italy, at 8mb/s, it was a different picture entirely.

Front-end engineering once again evolved at a feverish pace in 2017. Here is a list of the most notable events of the past year.

React continues to dominate the front-end landscape, and 2017 provided one of the most anticipated releases yet with version 16. It includes the fiber architecture which enables asynchronous UI rendering. This release also makes it much easier to manage unexpected application failures by providing error boundaries along with many other features.

Surprisingly, the most important improvement to React this past year wasn’t the new features, but the change to its open source license. Facebook shed its BSD license that was causing companies to move away from React and adopted the

Front-end engineering once again evolved at a feverish pace in 2017. Here is a list of the most notable events of the past year.

React continues to dominate the front-end landscape, and 2017 provided one of the most anticipated releases yet with version 16. It includes the fiber architecture which enables asynchronous UI rendering. This release also makes it much easier to manage unexpected application failures by providing error boundaries along with many other features.

Surprisingly, the most important improvement to React this past year wasn’t the new features, but the change to its open source license. Facebook shed its BSD license that was causing companies to move away from React and adopted the

The popularity of TypeScript has really exploded recently. I like TypeScript, and I like static types. I don’t use TypeScript, but as type systems go, it’s got some great features. It’s structural rather than nominal, meaning that it works basically like automatic duck typing rather than name or identity based type checking. That is a good fit for dynamic languages like JavaScript.

What I don’t like is that a lot of people think that TypeScript solves a problem that it doesn’t actually solve — at least, not to any significant degree.

The famous marketing rhetoric is “large-scale web applications are hard without static types”. It’s true that static types power some really great developer tools such as jump to definition and automatic refactoring, and those tools

We have been experimenting with a couple of approaches to bring Mono to the web using WebAssembly - a technology that can efficiently and safely execute code in web browsers without being limited to Javascript. Running code written in C or C++ inside the browser has been a big motivator, but most major programming languages have plans to target WebAssembly as a platform.

WebAssembly has been out for a few months on desktop computers and Android, and with the introduction of iOS 11 it will become nearly universal.

We have done some exploratory work to identify what needs to be done to run Mono on the browser. The early experiments are promising, let me talk about those.

If you’ve had any contact with JavaScript code, you’re probably very familiar with how to define and call functions, but are you aware of of how many different ways you can define a function? This is a common challenge of writing and maintaining tests in Test262—especially when a new feature comes into contact with any existing function syntax, or extends the function API. It is necessary to assert that new or proposed syntax and APIs are valid, against every existing variant in the language.

The following is an illustrative overview of the existing syntactic forms for functions in JavaScript. This document will not cover Class Declarations and Expressions, as those forms produce an object that is not “callable” and for this article, we’ll only be looking at forms that produce “callable” function objects. Additionally, we will not be covering non-simple parameter lists (parameter lists which include default parameters, destructuring, or a trailing comma), as that’s a subject worthy of its own article.

So you’ve read all the great reasons to go API-first, and you’ve produced a great looking single page app to display your content. But how do you serve it to the user?

You COULD set up a full Node server to host, route and serve your site. Or you could just host your website statically using AWS S3 and CloudFront! This means you simply put your website source files online, and they’re served immediately to the user, no server processing needed.

There are several big advantages to static hosting with client-side rendering: + Blazing Fast (no server preprocessing) + Really simply (no server architecture to maintain) + Crazy Available (your server can’t break if there isn’t one) + Instant Updates (don’t have to wait for the site to rebuild to see your changes)

When Brendan Eich created the very first version of JavaScript for Netscape Navigator 2.0 in merely ten days, it’s likely that he did not expect how far the Slack Desktop App would take his invention: We use one JavaScript code base to build a multi-threaded desktop application, routinely interacting with native code, targeting Windows, macOS, and Linux.

Managing large JavaScript codebases is challenging — whenever we casually pass objects from Chrome’s JavaScript to Objective-C just to receive a callback on a different thread in Node.js, we need a guarantee that the individual pieces fit together. In the desktop world, a small mistake is likely to result in an application crash. To that end, we adopted

Do you sometimes try position: relative then absolute then relative again? Does it take you more than 2 seconds to decide whether you’re going to use padding or margin? Have you ever added more than 5 classes to make your CSS work?

If you said yes to one of these questions don’t be ashamed, you’re not alone. But don’t be afraid, acquiring those skills is a lot easier than you probably think.

Relative or Absolute? Find the reference of your movement!

The position attribute has 5 different values: static, relative, absolute, fixed and sticky. Whereas fixed is quite straightforward and sticky is still barely used

Copy Static Files: Copy other static files which are not ended with .md or start with _

Sub Page and Sub Layout: For each markdown file, it will walk your file system looking for the nearest _layout.js as the template. It starts from the current directory of the markdown file and then moves to the parent directory until it finds the _layout.js