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.
Key features that landed:
- Arrow functions and template strings: Near-universal adoption
- let and const: Replacing var gradually
- Classes: Controversial but widely used
- Modules: Standard syntax, waiting for browser support
- Promises: Finally standardized
- Destructuring: Changing how we write JavaScript
The yearly release cycle (ES2016 next year) means JavaScript evolves continuously now. This is new—after years of stagnation (ES5 in 2009, ES6 in 2015), annual updates change expectations.
React's Dominance
React went from challenger to dominant frontend framework. Not universal, but clearly winning mindshare:
- React Native proved React's patterns work beyond web
- Redux gave React state management that stuck
- The ecosystem matured (routing, data fetching, testing)
- Companies at scale (Netflix, Airbnb, Facebook) validated it
Angular 2's complete rewrite and delayed release helped React. Ember remained solid but niche. Vue emerged as the "simpler React" but is early.
React isn't perfect—it's just good enough and has momentum. Network effects compound.
Tooling (Kind Of) Stabilized
Build tools were 2014's chaos. 2015 saw consolidation:
Babel won transpiling. Traceur is done. ES2015 via Babel is standard.
webpack won bundling. browserify remains viable but webpack's features (code splitting, HMR) proved decisive for SPAs.
npm won package management. Bower is slowly dying. npm 3's flatter dependencies addressed frontend concerns.
This isn't complete stability—webpack's configuration still confuses, Babel's plugins proliferate. But the churn slowed. Teams can pick tools with confidence they won't immediately obsolete.
Patterns Over Frameworks
Component architecture became the obvious pattern. React components, Web Components, Angular 2 components—everyone converged.
Functional programming patterns gained traction. Pure functions, immutability, composition—Redux popularized these ideas. Not dogmatic FP, but FP-influenced.
Unidirectional data flow became standard. Two-way binding's complexity convinced the community that one-way is simpler.
These patterns transcend frameworks. Whether you use React or something else, these ideas apply. This suggests maturity—patterns emerging from experience, not imposed by frameworks.
What Didn't Happen
Web Components didn't take over. Still a standard, still not widely used. Framework-specific components won.
Angular 2 didn't ship. Beta in 2015, final release pushed to 2016. The delay gave React room to grow.
Mobile web didn't eclipse native. Progressive Web Apps are promising but early. React Native is interesting but unproven at scale. Native apps remain dominant.
JavaScript fatigue peaked. The community acknowledged the problem. The response was mixed—some consolidation, some new tools adding to chaos.
The Node.js Reunification
Node and io.js merged, forming the Node.js Foundation. Node 4.0 brought modern JavaScript to server-side.
The significance is governance more than features. Open foundation model vs corporate control—this is an experiment in community-driven development.
Whether it works long-term is unknown, but initially promising. Faster releases, ES2015 support, stability commitments—these address past complaints.
GraphQL and Apollo Launched
Facebook open-sourced GraphQL in July. It's too early to call success, but the pattern—clients querying exactly what they need—is compelling.
GraphQL might be "REST, but better" or "Facebook-scale overengineering." 2016 will reveal which as the ecosystem matures.
The Async/Await Horizon
ES2016 (coming next year) brings async/await—cleaner asynchronous code. Babel supports it now experimentally:
async function fetchUser() {
const response = await fetch('/api/user');
const user = await response.json();
return user;
}This could be as transformative as Promises. Callback hell and Promise chains might become historical artifacts.
What 2016 Needs
JavaScript evolved rapidly. Now it needs consolidation:
Documentation. So many tools, libraries, patterns—but scattered docs. Comprehensive, maintained guides are rare.
Best practices. The ecosystem evolved faster than established patterns. What works at scale is still being discovered.
Stability. Not stagnation—just predictable evolution. Let tools mature before replacing them.
Accessibility. The learning curve is steep. New developers face overwhelming choices and complex tooling.
Performance focus. JavaScript bundles are large. Load times suffer. The ecosystem needs to prioritize performance.
2015 in Perspective
This was the year JavaScript became a serious application platform. Not a scripting language enhanced with frameworks—a full platform with tooling, patterns, and ecosystem.
The churn continues but feels purposeful now. Not change for change's sake—evolution toward better abstractions.
Frustrations remain. The tooling is complex. The framework landscape is fragmented. Learning JavaScript in 2015 is harder than 2010.
But the platform is better. Powerful features, rich ecosystem, patterns that work at scale. JavaScript delivered on its potential in 2015.
Looking forward to 2016, I expect refinement over revolution. The foundations are solid—time to build on them rather than replace them.
Here's to JavaScript growing up.
Resources:
- State of JavaScript Survey – (2016 first survey, concept exists)
- JavaScript Weekly – Tracking ecosystem
- ES2016 Features – What's coming
