Categories
JavaScript Web Development Year in Review

JavaScript in 2017: The Year of Stabilization

If 2016 was the year of JavaScript fatigue, 2017 was the year of JavaScript stability. No major framework wars. No revolutionary new tools that forced everyone to rewrite everything. Just steady iteration, performance improvements, and maturation of existing technologies.

This is less exciting than previous years, but more productive. The JavaScript ecosystem is growing up.

The Framework Landscape Settled

The big three frameworks solidified their positions:

React – Still dominant, especially in the U.S. React 16 shipped with Fiber, proving Facebook can execute large rewrites without breaking the ecosystem.

Categories
JAMstack JavaScript React

Gatsby and the Static Site Renaissance

Static site generators are having a moment. Gatsby, the React-based SSG, is growing fast. Netlify is building a business around static hosting. The term "JAMstack" (JavaScript, APIs, Markup) is catching on. After years of everything being a server-rendered app, we're rediscovering that static HTML is often the right answer.

What Gatsby Does

Gatsby generates static websites using React and GraphQL. Write components, query data, run the build, and get plain HTML/CSS/JS files. Deploy anywhere—no server needed.

import React from 'react';
import { graphql } from 'gatsby';

export default function BlogPost({ data }) {
  const post = data.markdownRemark;
  return (
    <article>
      <h1>{post.frontmatter.title}</h1>
      <div dangerouslySetInnerHTML={{ __html: post.html }} />
    </article>
  );
}

export const query = graphql`
  query($slug: String!) {
    markdownRemark(fields: { slug: { eq: $slug } }) {
      html
      frontmatter {
        title
      }
    }
  }
`;

At build time, Gatsby:

Categories
Frontend JavaScript React

React 16: Fiber Ships, Error Boundaries Arrive

React 16 is shipping with Fiber, the complete rewrite of React's core algorithm. After 18 months of development, the new reconciliation engine is production-ready. For most developers, upgrading means changing one line in package.json. That's the real achievement—rewriting the core without breaking the world.

What's New

React 16 brings several major features:

Fiber – The new reconciliation algorithm that enables:

Categories
Frontend JavaScript React

React Fiber: Rewriting the Core Without Breaking Everything

React is undergoing a complete core rewrite called Fiber, and most developers won't notice. That's the point. Facebook is replacing React's reconciliation algorithm—the diff engine that makes React fast—without changing the public API. This is a remarkable engineering feat and a lesson in managing large-scale architectural changes.

What Is Fiber?

Fiber is a complete rewrite of React's core algorithm. The current version (React 15) does reconciliation synchronously—when state changes, React computes the entire component tree diff in one uninterruptible block. If that takes 100ms, the main thread is blocked for 100ms. No user input, no animations, nothing.

Fiber breaks reconciliation into chunks. React can pause diff work, check if there's higher priority work (like user input), handle that, then resume diffing. The result: smoother user experiences, especially on slower devices.

Categories
JavaScript Web Development Year in Review

JavaScript in 2016: The Consolidation Year

Last year's prediction was that 2016 would focus on consolidation over innovation. Looking back, that's exactly what happened. React solidified position, Angular 2 shipped, tooling matured, and new frameworks emerged without fragmenting ecosystem completely.

2016 wasn't "everything changed again." It was "things settled."

Framework Landscape Solidified

Categories
JavaScript React Tooling

Create React App: Zero Configuration Done Right

Create React App launched this week, and it's the most significant React ecosystem development since Redux. Not because of what it does—setting up React projects—but how it does it: zero configuration, hidden complexity, sane defaults.

This is Facebook acknowledging JavaScript tooling is too complex and doing something about it.

The Tooling Complexity Problem

Categories
Frameworks JavaScript Web Development

Vue.js 2.0: The Framework That Came From Nowhere

Vue.js 2.0 is in development and coming this year. What started as Evan You's personal project in 2014 has become a legitimate third option alongside React and Angular. Vue's growth, especially in Asia, proves a framework can succeed outside the Facebook/Google ecosystem.

The question is whether Vue's "progressive framework" philosophy is genuinely better or just different.

The Progressive Framework Pitch

Categories
Frameworks JavaScript Web Development

JavaScript Frameworks in 2016: A New Hope

Two years ago, choosing a JavaScript framework felt like Russian roulette. Would it survive? Would it change completely? Would something better emerge next month? Starting 2016, those questions feel answerable. The landscape has stabilized enough to make informed choices.

This isn't declaring winners—it's acknowledging that viable options exist and the churn has slowed.

The Big Three Emerging

Categories
JavaScript Web Development Year in Review

JavaScript in 2015: The Maturation Year

Last year's post was titled "JavaScript in 2014: The Year Everything Changed (Again)." This year feels different. Not "everything changed again"—more "things settled into place." ES2015 shipped, React matured, patterns emerged. This was JavaScript growing up.

ES2015: From Experimental to Standard

ES2015 (ES6) finalized in June. But unlike most standards, developers had been using it for months via Babel. The finalization formalized what was already practice.

The shift from "experimental features" to "standard language" matters psychologically. Teams that resisted transpiling because ES6 felt unstable are now adopting it. Babel moved from optional to essential infrastructure.

Categories
CSS JavaScript Web Development

CSS-in-JS: Heresy or the Future?

The React community is experimenting with writing CSS in JavaScript—inline styles defined as objects, styling colocated with components, no separate stylesheets. This violates web development orthodoxy so completely that the reaction ranges from "interesting" to "what heresy is this?"

After building with CSS-in-JS approaches, I think the heresy might be onto something. But the trade-offs are real.

The Traditional Separation