It's hard to escape the gravity of internet giants like Facebook and Google. Not only do they offer an ever-growing number of apps and services that are hard to live without, many other popular websites and applications incorporate code written by these companies.

That's because today's web developers don't typically write all of their code themselves. Instead, they rely on open source "frameworks," which provide both a collection of reusable parts and an overall structure for building an application. Frameworks free developers from much grunt work, allowing them to focus on the newer, more interesting parts of an application.

What framework are you using? Are you using Bootstrap, or Materialize, or Foundation? Or Vue, or Angular 1, or Angular 2, or Ember? Or Ruby on Rails, or Sinatra, or Express, or Meteor, or Flask, or Korbin, or Hapi, or Spring, or...

Frameworks are all terrible. All of them. I'm serious - they are making you all into bad developers. Stop using them now.

Let's talk about this, as I may have lost most of you with that opening. Why do people like you like frameworks? Are you weak or are you stupid? Or both?

Sure, I'm building a bike. I don't need to reinvent the wheel, I'll just grab a framework with a wheel.

It's hard to escape the gravity of internet giants like Facebook and Google. Not only do they offer an ever-growing number of apps and services that are hard to live without, many other popular websites and applications incorporate code written by these companies.

That's because today's web developers don't typically write all of their code themselves. Instead, they rely on open source "frameworks," which provide both a collection of reusable parts and an overall structure for building an application. Frameworks free developers from much grunt work, allowing them to focus on the newer, more interesting parts of an application.

JavaScript is an adventure. After almost a decade of both amateur and professional development in various industries, I believe everybody would agree on this one statement.

Frontend projects give us, programmers, a lot of freedom of choice, of flexibility, and plenty space for creativity — but in return they also demand a bit of knowledge, planning, and self-responsibility.

Having gone through projects with jQuery, require.js, Angulars, React, ExtJs, and maybe a dozen others I may not recall (or wish to not recall) — I have seen things unimaginable to 2018's Frontend. And we all probably did at some point!

A little-known fact is that Uber builds a lot of web-based applications, hundreds of them and counting, in fact. Many of them are internal apps for managing various aspects of the business while others are public facing.

A more well-known fact is that web technologies change quickly and best practices are constantly evolving. Providing a high quality framework with modern features to hundreds of web engineers while keeping up with the dynamic nature of the web platform has historically been a challenge.

To address this challenge, Uber’s Web Platform team built Fusion.js, an open source web framework that makes web development easier and produces lightweight, high-performing apps.

In a rush? Skip to:

1. A JavaScript story
2. What is vanilla JavaScript?
3. JavaScript frameworks: pros & cons
4. Why learn plain JS before frameworks
5. Open source list of vanilla JS resources
6. TL;DR

Rewind to 2013. ⏪

Our small dev team is about to ship one of its most impressive client projects to date. I'm at my stand-up desk, skimming through morning emails. My partner bursts through the office door:

"Something's wrong with our Angular app, man. I've got a digest is already in progress error popping everywhere—can't figure out what's happening," he says, visibly nervous.

But I'm not nervous, nor stressed. I know exactly where to start looking, because I know my JavaScript.

For many front-end developers, components have become a central concept in their development workflow. Components provide a robust model for architecting and scaling complex applications, allowing for composition from smaller and simpler encapsulated parts. The concept of the component has existed on the web for some time, with frameworks like the Dojo Toolkit championing them in its Dijit widget system early on in the JavaScript ecosystem.

Modern frameworks like React, Angular, Vue, and Dojo have further put components at the forefront of development, keeping them as core primitives in their architecture. However, even though component architectures have become more common, arguably the diversity of frameworks and libraries has led to a siloed and fragmented components market. This fragmentation has often kept teams locked into a specific framework, even as times and technologies change.

’Tis a gift to be simple. Increasingly, in our line of work, ’tis a rare gift indeed.

Article Continues Below

In an industry that extols innovation over customer satisfaction, and prefers algorithm to human judgement (forgetting that every algorithm has human bias in its DNA), perhaps it should not surprise us that toolchains have replaced know-how.

Likewise, in a field where young straight white dudes take an overwhelming majority of the jobs (including most of the management jobs) it’s perhaps to be expected that web making has lately become something of a dick measuring competition.

It was not always this way, and it needn’t stay this way. If we wish to get back to the business of quietly improving people’s lives, one thoughtful interaction at a time, we must rid ourselves of the cult of the complex. Admitting the problem is the first step in solving it.

As the earliest, most comprehensive JavaScript framework, the Dojo Toolkit offered up intelligent building blocks for serious web developers. For example, Dojo’s very early work on deferreds and async patterns, widgets, modules, i18n, and a11y led to the standardization of promises, fetch, web components, ES modules and other best practices and mainstays of modern web development. Dojo was the first open source JavaScript framework that treated JavaScript and the browser as a platform for building robust software applications. Its focus on pushing the limits of the open web with diligent consistency means that applications authored in 2007 with Dojo still work today!

When you stop trying to over-optimize, you should notice considerably fewer variables in your template files. I recommend that you take that idea a step further and try to avoid variables in template files in general. Not because you should avoid variables themselves, but because of what they’re a symptom of in template files — logic.

While some logic will always be necessary, you can improve the readability of your template files significantly by removing as much as you can.

Here is a simple example.

<?php $logo_url = false; $thumbnail_url = wp_get_attachment_image_src( get_theme_mod( 'hypthetical_theme_logo' ), 'full' ); if( $thumbnail_url ) { $logo_url = $thumbnail_url[0]; } ?> <?php if( $logo_url ): ?> <a href="<?php echo esc_url( home_url() ); ?>" title="<?php bloginfo( 'name' ); ?>" class="custom-logo"> <img src="<?php echo $logo_url; ?>" /> </a> <?php endif; ?> 

Deciding on a JavaScript framework for your web application can be overwhelming. Angular and React are very popular these days, and there is an upstart which has been getting a lot of traction lately: VueJS. What’s more, these are just a few of the new kids on the block.

First, I’d like to discuss lifecycle & strategic considerations. Then, we’ll move to the features & concepts of the three javascript frameworks. Finally, we’ll come to a conclusion.

Here are the questions we’ll address today:

• How mature are the frameworks / libraries?
• Are the frameworks likely to be around for a while?
• How extensive and helpful are their corresponding communities

By Christine Zierold, Freelance QA Engineer

Want to learn a little more about TestCafé and Nightwatch.js? Christine Zierold compares and contrasts the two UI Test Automation frameworks to help explain the benefits and drawbacks of each.

What is TestCafé?

TestCafé is an end-to-end testing framework, written in JavaScript (JS) or Typescript. It does not leverage Selenium like most other test automation frameworks but instead utilizes a URL-rewriting proxy. TestCafé imitates user activity through the injected driver script by the proxy.

What is Nightwatch.js?

Nightwatch.js is also an end-to-end testing framework based on

In the world dominated by Bootstrap, surrounded by Semantic UI and Foundation, it’s hard for alternatives to break through.
However the mentioned trio is well known, mature and exist on the market for quite long now, they’re all relatively heavy and they all require deep understanding of the core, while doing customisations (have you ever done custom dropdowns in Semantic??!).

There comes Bulma. Beautiful, lightweight and stylish CSS framework made by Jeremy Thomas. If you haven’t done it already – I encourage you to visit his website – the site just lives in the browser! It’s super-interactive, beautiful and it’s

Updated Jan. 21st, 2018: Added AppRun and dva.

Keeping up with JavaScript frameworks can be a challenge. There are a lot of them, and seemingly another one every month. How do you know which ones might be right for your project? What are their strengths and weaknesses? How do you get started?

That’s where this guide comes in. It’s a living document that is a reference for all known front end JavaScript frameworks (archived or deprecated projects are not included). In this case, the term “frameworks” is being used in a broad sense. It includes user interface (UI) libraries like React, as well as full frameworks like Angular.

In 2014, the WebKit team at Apple released Speedometer 1.0, a benchmark for web app responsiveness. It simulates user interactions in web applications, using TodoMVC to orchestrate adding, completing, and removing todo items. Speedometer repeats these actions using DOM APIs that were extensively used in real-world applications. The performance of these kinds of operations depends on the speed of the JavaScript engine, DOM APIs, layout, CSS style resolution and other parts of the browser engine.

Browser engineers have been optimizing their engines using Speedometer as a proxy for real-world use of popular frameworks for a number of years. Originally, Speedometer included implementations of todo apps in six popular JavaScript frameworks and libraries in heavy use: Ember, Backbone, AngularJS, jQuery, Flight, and an early version of React. It also included vanilla JavaScript.

JavaScript UI frameworks and libraries work in cycles. Every six months or so, a new one pops up, claiming that it has revolutionized UI development. Thousands of developers adopt it into their new projects, blog posts are written, Stack Overflow questions are asked and answered, and then a newer (and even more revolutionary) framework pops up to usurp the throne.

Using the Stack Overflow Trends tool and some of our internal traffic data, we decided to take a look at some of the more prominent UI frameworks: Angular, React, Vue.js, Backbone, Knockout, and Ember.

Stack Overflow Trends lets us examine how each of these technologies has been asked about over time. We can start by looking at some of the larger frameworks.

Web performance is a big and complex topic. In this post we’ll narrow it down to a discussion of front end JavaScript frameworks and how using one versus another might impact the performance of your app. In particular, we’ll be looking at two things: (1) how long it takes a framework to update the user interface, and (2) the time required to download and parse the package(s) required for the framework to be functional.

My go-to resource for this data over the last couple years has been the js-framework-benchmark by Stefan Krause. It’s good, but also kind of complicated. It’s easier to look at a subset of the results, and that’s what we’ll be doing in this article. I encourage you to check out the tool Stefan has built and dig into more of the data on your own, particularly if your favorite framework is missing from the graphics below. It may be available on Stefan’s site (he tests 40+ frameworks).

Taking the next-plus-one step

If you had to list the characteristics of the perfect Node.js web application framework, you'd probably come up with something like this:

Next.js is close to this ideal. If you haven't encountered it yet, I strongly recommend going through the tutorials at learnnextjs.com. Next introduced a brilliant idea: all the pages of your app are files in a your-project/pages directory, and each of those files is just a React component.

Everything else flows from that breakthrough design decision. Finding the code responsible for a given page is easy, because you can just look at the filesystem rather than playing 'guess the component name'. Project structure bikeshedding is a thing of the past. And the combination of SSR (server-side rendering) and code-splitting — something the React Router team

Software development teams often make decisions about software architecture or technological stack based on inaccurate opinions, social media, and in general on what is considered to be “hot”, rather than solid research and any serious consideration of expected impact on their projects. I call this trend Hype Driven Development, perceive it harmful and advocate for a more professional approach I call “Solid Software Engineering”. Learn more about how it works and find out what you can do instead.

Have you seen it? A team picking newest, hottest technology to apply in the project. Someone reads a blog post, it’s trending on Twitter and we just came back from a conference where there was a great talk about it. Soon after, the team starts using this new shiny technology (or software architecture design paradigm), but instead of going faster (as promised) and building a better product they get into trouble. They slow down, get demotivated, have problems delivering next working version to production. Some teams even keep fixing bugs instead of delivering new features. They need ‘just a few more days’ to sort it all out.

Recently I published an article about the usage of top front end JavaScript frameworks. The two things that stood out were the dominance of React and the explosive growth of Vue. If current trends continue, it seems likely that by this time next year, Vue will have overtaken Angular as the second most used library or framework.

I've been using React for the last three years building websites for a client services company. Most of the time, the client comes to us specifying that they want to use React. However, it seems only a matter of time before Vue is a bigger part of those discussions. What follows is my first pass at better understanding the differences between these two libraries so I can give better advice to our clients.

It has come time to read the liner notes and write some conclusions. When we started writing this blog series, we knew that JavaScript/web application frameworks were not easy to summarize. We have tried to answer the unanswerable: What framework should I use?

In this post we are going to draw some conclusions about each framework considered in this series, including what we think are their strengths and weaknesses. In addition, we will give you some parting thoughts to consider.

This is part of a series on web frameworks. If you’ve missed our previous posts, you may want to start with If we chose our JavaScript framework like we choose our music…

A few days ago Netflix tweeted that they'd removed client-side React.js from their landing page and they saw a 50% performance improvement. It caused a bit of a stir.

The following:

1. Download HTML & CSS in parallel.
2. Wait for CSS to finish downloading & execute it.
3. Render, and continue rendering as HTML downloads.

…is always going to be faster than:

1. Download HTML (it's tiny).
2. Download CSS & JS in parallel.
3. Wait for CSS to finish downloading & execute it.
4. Wait for JS to finish downloading & execute it.

Over the past few months, I’ve been asked the same general question about Angular multiple times in onsite training classes, while helping customers with their architecture, or when talking with company leaders about the direction web technologies are heading. Here’s the general question:

“What are the key benefits that Angular and TypeScript can offer our development teams?”

It’s a great question and one that should be asked before jumping into any new technology or framework. Most of the people asking are technology managers or directors interested in understanding the benefits that Angular can offer their teams (both technical and non-technical). They’re concerned about application maintenance, developer productivity, handling change requests, the longevity of the framework, the pace of technology, and more.

Hello, I'm Arthur Guiot, I created DisplayJS not that long ago, and I figured out that I couldn't find an easy to setup testing framework. So, I wanted to create my own, and here it is. EyeJS is easy to setup, and has some unique features, such as the ability to test your project right in a browser, which make it adapted to real world test.

Speed

Where other testing frameworks (such as Jest) are pretty slow, EyeJS can do your tests under milliseconds

Features

EyeJS is made for the real world, so yes, other framework like Jest (yes, I'm comparing with Jest because it's the only one I know 😊), will have a richer API on the paper,

Dimitri Glazkov, Alex Komoroske, and I started the project that designed and (for many years) iterated on Web Components with a few primary goals in mind:

• Enhance component portability
• Shrink the amount of infrastructure code required over-the-wire and at runtime
• Enable the browser to optimize components

All of this was wrapped up in our project’s mantra: “say what you mean”.

Our position was (and is) that developers shouldn’t need to write the word function when they meant class or module and they shouldn’t have to type <div class="tree-control"> or torture existing HTML elements to “mean” something they clearly did not. JavaScript programmers should be able to instantiate components naturally (

Framework Churn: that breakneck pace of creation and abandonment that plagues the JavaScript community. Here one day, out the next. Hot today, obsolete in a year. Number one loved on the Hacker News frontpage, now number one hated on the Hacker News comments.

Framework Churn is something every one of us deals with in the JavaScript community. How do we know that big investment we’re making in Tool/Framework X is going to be relevant in a year, five years, twenty years? It’s at the point now that many are afraid to pick anything for fear it’ll be irrelevant long before the life of the product built with it.

The purpose of this post is to emphasize the importance of JavaScript fundamentals for every front-end developer. I’m going to tell you why you should have a good knowledge of pure (Vanilla) JavaScript. This means JavaScript without any additional frameworks or libraries.

I’ll also mention a couple of resources that helped me to learn these basics.

Another reason behind this post is that many aspiring web developers tend to skip learning core JavaScript concepts such as hoisting, closures, or prototypes. They go straight to the hottest frameworks such as React or Angular 2. I’ll show you why this approach is not the most convenient one.