spellbook-of-modern-webdev
v3.2.2TypeScript
spellbook-of-modern-webdev
0/weekUpdated 1 years agoMITUnpacked: 241.8 KB
Published by dexteryy
npm install spellbook-of-modern-webdev
Spellbook of Modern Web Dev
A Big Picture, Thesaurus, and Taxonomy of Modern JavaScript Web Development
- This document originated from a bunch of most commonly used links and learning resources I sent to every new web developer on our full-stack web development team.
- What I'm doing in this document now is trying to provide the complete view angle of modern web (app or page) development ruled by JavaScript, reflect technological advance and help developers to acquire APIs, libraries, tools, services, best practices and learning resource which are not outdated and most commonly used.
- I hope this document can help one developer to have more power to do much more and much better, just like a spellbook does in fantasy worlds.
- The JS/web technology is like an ocean of stuff you don’t know. Simply collecting more stuff or composing dozens of "awesome lists" into a single one will only exacerbate the Javascript Fatigue. So this document must stay lean and focus on the most frequent problems and the most commonly used stuff.
- So for each problem domain and each technology, I try my best to pick only one or a few links.
- Which link belongs to "not outdated and most commonly used stuff" is not only decided by clear trends, empirical observation, and working experience, also by public data and web scraping scripts.
- The npm package statistics (like download count) are given more weight than Github repo statistics (like starring data) because npm statistics can better reflect the actual usage and popularity.
- Prefer fine-grained classifications and deep hierarchies over featureless descriptions and distractive comments.
- Ideally, each line is a unique category. The " / " symbol between the links means they are replaceable. The ", " symbol between the links means they are complementary.
- I wish this document could be closer to a kind of knowledge graph or skill tree than a list or a collection.
- It currently contains 2000+ links (projects, tools, plugins, services, articles, books, sites, etc.)
- Feel free to submit the missing or better links in your opinion. Also, please provide the reason.
- Why not add a Europe (or other regions) section? Why not add your project? Why so many React-based projects? Why not Angular/Vue.js/XXX?
#### Understanding Modern Web Development
- In English: coming soon...
- In Chinese: slides @ JSConf CN 2017
---
Table of Contents
- Platforms and Languages
- Open Web Platform
- Learning, Reference, Visual Tools
- Performance, Security, Semantics / SEO / Accessibility
- HTML5 / Web APIs
- HTML/DOM, Appearance, Interaction, Access, Network, Media, Graphics, Computing...
- CSS Features
- RWD, Layout, Typography, Text, Animation, Effects...
- Modern CSS / Next-Gen CSS
- CSS Module, PostCSS, CSS in JS
- Best Practices (Skeleton, Methodology, Code Style...)
- Know More about Web Design / UI Design / UX Design (RWD, Atomic Design, Motion Design, Grid System, Typography, Style Guide...)
- Modern JS / Next-Gen JS
- ES6+ Features, Intro to ES6+, Re-intro to JS, Important Proposals, Functional Programming, FRP, Static Typing, Code Style...
- WebAssembly
- Concepts, Features, Rust, ...
- Node.js
- Intro, Workshop, Best Practices...
- Platform Compatibility and Proposal Status
- Platform Status / Releases / Updates, ECMAScript Compatibility
- Proposal Status (W3C WG, WICG, WHATWG, ECMA TC39, Node.js CTC)
- JS Engine (V8, JSC, Chakra), Web/JS Runtime (Electron, Cordova, React Native...), Device...
- Cross-browser / Polyfill Libraries
- Appearance, Interaction, Access, Network, Performance, Offline, Media...
- npm Ecosystem
- Finding Packages (Search, Stats, Rank)
- Dependency Management / Release / Maintenance (npm, yarn, lerna, ncp...)
- Convention (Open Source, SemVer, package.json, Small modules, Isomorphic JS / Universal JS...)
- Universal Utility Libraries
- Standard Library Extensions (FP, OOP, Async...)
- Hashing / Generating
- Parsing / Manipulating (URL, Validator, i18n, Date, Numbers, Color, Text, Buffer / Blob...)
- Logic, Network, Storage, NLP, ML...
- Universal Web Apps / Web Pages
- GUI Framework
- View / ViewModel / ViewController (React)
- Model / App State (Redux)
- API (GraphQL)
- GUI Architectures (MVC, MVP, PM, MVVM, Flux, Redux, Elm, MVI, SAM...)
- UI Toolkits
- CSS, React...
- Standalone UI Components
- Layout, Icon, Button, Form, Overlay, Picker, Content, Editor...
- Client Side
- UX Libraries
- Drag & Drop, Gesture, Scrolling, Zoom, Tooltip, Tour...
- Graphic Libraries
- Animation (Effects, Loading, Scrolling, Parallax, Transition, Timeline, Motion / Curved Path...)
- 2D (Canvas, SVG, Physics...), 3D (WebGL, Physics...)
- Data Visualization, Game...
- Hybrid Libraries
- Electron, React Native
- Server Side
- Network
- HTTP (Intro, Same-origin policy, Performance, HTTPS, HTTP/2, gRPC...)
- TCP, UDP...
- Server-side Best Practices
- Restful API, SaaS, Microservices (API Gateway, Serverless)
- Cloud / Distributed, Web Hosting / Non-distributed
- Authentication / Authorization, Security, Logging / Monitoring, DevOps...
- Microservices / API Services (Node.js)
- Frameworks (RESTful API, Microservices, Serverless, Bots...), GraphQL, DocGen + CodeGen...
- Server-side Libraries (Node.js)
- Configuration, Debugging, Protocols, Network, Crypto, Auth, Storage, Jobs, Scraping, Images, Parsing / Generating, NLP...
- Cloud Services (Global)
- Compute (FaaS / Serverless / WebHook, PaaS, CaaS)
- Storage (Object Storage, DBaaS)
- BaaS (CRUD, Auth, Search, Email, SMS...)
- AIaaS / BDaaS (Natural Language, Computer Vision...)
- Cloud Services (China)
- The evil twins inside the Great Firewall of China
- Tooling
- Testing
- Unit Testing / Test Runner, Test Doubles
- Web Testing (Integration Testing, Functional/E2E Testing, Visual testing, Monkey Testing, Headless Browsers)
- Server-side Testing (Functional Testing, Load Testing)
- Benchmark Testing
- Analysis (Code Coverage, Node.js Security...)
- Documentation
- JS, API, CLI, CSS / Style Guide, Writing
- Toolchain
- Compiler / Transpiler / Preprocessor (Babel, PostCSS...)
- Loader / Builder / Bundler (Webpack, Rollup...)
- Minifier / Compressor / Optimizer (Prepack, Babili / Uglify, imagemin, cssnano / clean-css...)
- Formatter (Prettier, Stylefmt...)
- Static Analysis (ESLint, Flow, StyleLint...)
- Task Automation (npm scripts, Gulp...)
- Workflow
- Development (Micro Generator, Live Reload / Watch / Preview, Dev Tools, HTTP Inspector, Debugging Proxy...)
- Deployment (Process Supervisor, Containers, Container Clusters, PaaS)
- Monitoring (Error Tracking, Logging, APM...)
- Command-line Environment (Mac)
- Terminal, Homebrew, Zsh, Vim, Git, Docker, dotfiles, Utilities...
- Command-line Libraries (Node.js)
- Input (Options/Arguments Parser, Interactive, Configuration...)
- Output (Color / Style, Icon, Updating Log, Notice, Columns, Curses, Drawing...)
- Delivery, OS, API, Parser...
- IDE / Editors
- VSCode Plugins (UI, Formatting, Operating, Static Analysis, Docs, Assistant, Integration...)
- Atom Plugins (UI, Formatting, Operating, Static Analysis, Docs, Assistant, Integration...)
- Out-of-the-box Atom IDE, Other Electron-based IDE, Programming Fonts...
- Useful Apps
- Playground, Visual Tools, Viewer, Docs, Automation...
- Collaboration
- Version Control, ChatOps, Kanban, Markdown, Design...
A Subset as a Learning Path
1. Open Web Platform
2. HTML5 / Web APIs
3. CSS Features
4. Modern CSS / Next-Gen CSS
5. Modern JS / Next-Gen JS
6. Platform Compatibility and Proposal Status
7. Network
8. Node.js
9. npm Ecosystem
10. Command-line Environment (Mac)
11. IDE / Editors
12. GUI Framework
13. Microservices / API Services (Node.js)
14. Testing
A Subset for Finding Libraries
- Cross-browser / Polyfill Libraries
- Hybrid Libraries
- GUI Framework
- UI Toolkits
- Standalone UI Components
- UX Libraries
- Graphic Libraries
- Universal Utility Libraries
- Microservices / API Services (Node.js)
- Server-side Libraries (Node.js)
- Command-line Libraries (Node.js)
A Subset for Architecture and Infrastructure
- GUI Framework
- Toolchain
- Workflow
- Microservices / API Services (Node.js)
- Server-side Best Practices
- Cloud Services (Global) / Cloud Services (China)
- Documentation
---
Platforms and Languages
$3
- Learning
- What is the Internet, How does the Internet work
- HTTP - see _Server Side > Network_
- Evolution of the Web
- Timeline of web browsers
- Dive Into HTML5 - A Quite Biased History of HTML5
- 20 Things I Learned About Browsers and the Web
- MDN's Learn Web Development
- Reference
- MDN Web Docs
- HTML, SVG, CSS, DOM, DOM Events, Web APIs
- MDN content Roadmap
- Google Developers
- Web Fundamentals, Update, HTML5Rocks Archived Tutorials
- Apple
- WebKit JS
- CSSDB
- CSS-Tricks's CSS Almanac, Codrops' CSS Reference
- Mastering CSS Principles: A Comprehensive Guide
- HTML: The Living Standard (Web Developer Edition)
- The Web platform: Browser technologies
- W3Fools
- W3Schools Responds to W3Fools
- Why shouldn't I use W3Schools?, Why do people hate W3schools?, Does W3Schools really suck?
- Visual Tools
- see _Tooling > Useful Apps > Visual Tools_
- Performance
- Rendering
- How Browsers Work: Behind the scenes of modern web browsers, \
How Browsers Lay Out Web Pages
- Rendering Performance
- GPU Animation: Doing It Right / An Introduction to Hardware Acceleration with CSS Animations
- CSS will-change
- Everything You Need to Know About the CSS will-change Property
- CSS Containment in Chrome 52
- Loading
- How DNS works
- Network resilience
- Evolution of Script Loading, Browser script loading roundup
- JavaScript Start-up Performance
- Critical Rendering Path,
CSS and the critical path
- Offline
- see _HTML5 / Web APIs > Offline_
- Measure
- Performance budgets 101
- Measure Performance with the RAIL Model
- Measuring Page Load Speed with Navigation Timing
- Measuring network performance with Resource Timing API
- User Timing API
- Why Web Developers Need to Care about Interactivity
- requestIdleCallback
- PerformanceObserver
- Optimization
- Fast load times
- Why Performance Matters
- Performance audits
- Lighthouse Audit References
- Security
- Safe and secure
- The Tangled Web: A Guide to Securing Modern Web Applications
- HTML5 Security Cheatsheet
- Semantics
- SEO
- Let’s Talk about Semantics
- Easily discoverable
- SEO audits
- SEO Tutorial For Beginners, \
Google's Search Engine Optimization Starter Guide
- Accessibility
- Accessible to all
- The A11Y Project, Using ARIA
\>\> Return to Table of Contents
$3
- HTML / DOM
- You Might Not Need jQuery, \
You Don't Need jQuery, \
(Now More Than Ever) You Might Not Need jQuery
- HEAD
- favicon
- Form pseudo-element
- Native form elements
- Detect DOM changes with Mutation Observers
- Appearance
- Web Components
- Shadow DOM v1, Custom Elements v1
- Web Animations
- Web Animation Past, Present, and Future
- Let's talk about the Web Animations API
- Status - Are we animated yet?
- Interaction
- Desktop
- MouseEvent, WheelEvent, KeyboardEvent
- Drag and Drop, Pointer Lock
- Mobile
- TouchEvent
- 300ms tap delay, gone away, More Responsive Tapping on iOS
- DeviceOrientationEvent + DeviceMotionEvent
- Hardware Agnostic
- PointerEvent, Selection
- Intersection Observer API (Intro)
- Resize Observer API
- Gamepad, Web Speech
- Access
- URL, History, Navigator, Screen, Page Visibility, Clipboard, Performance, Console
- Permissions, Geolocation
- Web Notifications , Vibration
- Network
- XMLHttpRequest2
- Fetch
- Abortable Fetch
- Why I won’t be using Fetch API in my apps
- WebSocket, Server-sent Event
- WebRTC
- Getting Started with WebRTC
- WebRTC in the real world: STUN, TURN and signaling
- WebRTC data channels
- Workshop - Codelabs - Real time communication with WebRTC
- Offline
- Overview
- Offline UX Considerations
- The offline cookbook
- Offline First - HTML5 technologies for a faster, smarter, more engaging web
- Web Storage, IndexedDB
- FileReader, File, Blob
- Service Worker
- Service Workers Explained
- Service Workers: an Introduction, The Service Worker Lifecycle
- Instant Loading Web Apps with an Application Shell Architecture
- Service Worker Cookbook
- Status - Is ServiceWorker Ready?
- Progressive Web Apps
- Progressive Web App Checklist, PWA audits
- Offline Storage for Progressive Web Apps
- The PRPL pattern
- Workshop - Codelabs - Your First Progressive Web App
- Media
- \
- Web Audio API
- Web Audio API Book
- Workshop - Web Audio School
- Media Streams
- Capturing Audio & Video in HTML5
- Graphics
- SVG
- Styling And Animating SVGs With CSS
- Canvas
- HTML5 Canvas
- WebGL
- WebGL by example, WebGL tutorial, Learning WebGL
- Primer: Shaders, An Introduction to Shaders
- The Book of Shaders
- Workshop -Shader School, WebGL Workshop, WebGL Academy
- Learning Modern 3D Graphics Programming
- WebXR / Immersive Web
- Welcome to the immersive web
- Progressive WebXR
- Computing
- Web Cryptography
- Web Workers
- WebAssembly
- see _WebAssembly_
\>\> Return to Table of Contents
$3
- Basics
- You Don't Need JavaScript
- CSS Selectors from CSS4 till CSS1
- CSS Diner - Where we feast on CSS Selectors!
- An Ultimate Guide To CSS Pseudo-Classes And Pseudo-Elements
- @supports Rule (Feature Queries)
- Houdini
- Houdini: Demystifying CSS, Houdini: Maybe The Most Exciting Development In CSS You've Never Heard Of
- Responsive Web Design
- Media Queries
- Media Queries for Standard Devices
- Images
- Responsive Images, Responsive Images in CSS
- Units
- Font Size Idea: px at the Root, rem for Components, em for Text Elements, \
Understanding and Using rem Units in CSS
- Truly Fluid Typography With vh And vw Units
- Layout
- Flexbox, CSS Grid Layout
- CSS Grid, Flexbox And Box Alignment: Our New System For Web Layout
- A Complete Guide to Flexbox (CSS-Tricks) / Flexbox (Codrops)
- Using Flexbox today
- Solved by Flexbox, Flexbox Patterns
- Centering Elements with Flexbox
- Quantity Queries with Flexbox
- A Complete Guide to Grid (CSS-Tricks) / A Complete Guide to CSS Grid (Codrops)
- Traditional
- Learn CSS Layout
- Learn CSS Layout - the pedantic way
- CSS Floats 101, All About Floats, CSS Float Theory: Things You Should Know
- CSS Positioning 101
- CSS “position: sticky” – Introduction and Polyfills
- The Z-Index CSS Property: A Comprehensive Look
- Centering in CSS: A Complete Guide, Absolute Center an Image, How To Center in CSS
- Web Typography
- Using @font-face
- A Comprehensive Guide to Font Loading Strategies
- Text
- Handling Long Words and URLs
- writing-mode + text-orientation
- Animation
- CSS Transition
- Using CSS transitions
- Intro to CSS 3D transforms
- CSS Animation
- The Guide To CSS Animation: Principles and Examples
- Upgrading CSS Animation With Motion Curves
- Motion Path
- Animating Clipped Elements In SVG
- Moving along a curved path in CSS with layered animation
- Future Use: CSS Motion Paths
- Effects
- CSS Image Effects
- Web Image Effects Performance Showdown
- Basics of CSS Blend Modes
- CSS Blend Modes could be the next big thing in Web Design
- Understanding CSS Filter Effects
- Clipping and Masking in CSS
- The State of CSS Reflections
- CSS Shapes 101
\>\> Return to Table of Contents
$3
- Component-based CSS
- Utility Class / Functional CSS / Utility-first CSS / Atomic CSS
- The Case for Atomic / Utility-First CSS
- CSS Utility Classes and "Separation of Concerns"
- A Year of Utility Classes
- So you need a CSS utility library?
- see _UI Toolkits_
- CSS Modules
- The End of Global CSS
- Tools - see _Tooling > Toolchain > Builder / Bundler > Webpack_
- Styled-Components / Emotion
- CSS in JS
- A Unified Styling Language
- A Brief History of CSS-in-JS: How We Got Here and Where We’re Going, The State of CSS
- Comparison of CSS-in-JS solutions
- Styled Components: Enforcing Best Practices In Component-Based Systems
- Writing your styles in JS ≠ writing inline styles
- Libraries
- styled-system, system-components, grid-styled
- styled-normalize / styled-sanitize
- styled-components-breakpoint
- styled-tools
- Preprocessor-based CSS
- PostCSS
- Intro
- Meet PostCSS
- PostCSS – A Comprehensive Introduction
- PostCSS – Sass Killer or Preprocessing Pretender?
- PostCSS Playground
- Preset Env
- It’s Time To Start Using CSS Custom Properties
- Getting Started With CSS calc()
- More Plugins - see _Tooling > Toolchain > Compiler / Transpiler / Preprocessor > PostCSS_
- Best Practices
- Sanitize.css / Normalize.css / Reset.css
- Methodology
- BEM
- BEM 101 / MindBEMding
- OOCSS
- An Introduction To Object Oriented CSS (OOCSS)
- SMACSS
- ITCSS, RSCSS, SOLID CSS
- CSS Guidelines, MaintainableCSS
- Code Style
- Idiomatic CSS
- Airbnb CSS / Sass Styleguide
- Airbnb CSS-in-JavaScript Style Guide
- CSS + HTML
- Isobar Front-end Code Standards
- Code Guide by @mdo
- Know More about Web Design / UI Design / UX Design
- Responsive/Adaptive Web Design
- Responsive Web Design Basics /\
Responsive Web Design: What It Is And How To Use It
- The Difference Between Responsive and Adaptive Design
- The Current State of Adaptive Design
- Responsivedesign.is - Design, Develop
- Patterns
- Responsive Web Design Patterns, \
Responsive Patterns, \
ResponsiveDesign.is Patterns
- Responsive Data Table Roundup
- Motion Design
- Creating Usability with Motion: The UX in Motion Manifesto
- 10 principles for smooth web animations
- Grid System - A Comprehensive Introduction to Grids in Web Design
- calc() grid system - Lost Grid
- flexbox grid system - Flexbox Grid
- The 8-Point Grid
- Typography
- Typography.js
- Gutenberg
- The Equilateral Triangle of a Perfect Paragraph
- The Elements of Typographic Style Applied to the Web
- Why is Vertical Rhythm an Important Typography Practice?
- CSS with vertical rhythm
- More Meaningful Typography
- Modular Scale
- Atomic Design (Book)
- The Atomic Workflow — People, Process, And Making Design Systems Happen
- The “Other” Interface: Atomic Design With Sass
- Atomic Design – Your Ultimate Guide to Scalable & Modular CSS (Sass)
- Design System
- A comprehensive guide to design systems, Design Systems Handbook
- Design Tokens
- Tokens in Design Systems
- How to manage your Design Tokens with Style Dictionary
- What Are Design Tokens?
- Style Guide
- Style Guide Driven Development / Living Style Guides
- Tools - see _Tooling > Documentation > Style Guide_
- Examples
- Apple's Human Interface Guidelines
- Google's Material Design
- Microsoft's Fluent Design System
- Airbnb's new design system
- Github's Primer
- Atlassian's Design Guidelines
- Salesforce's Lightning Design System
- Yelp's Styleguide
- IBM's Living Language
- BBC's GEL Guidelines
- A List Apart's pattern library
- USA.gov's Web Design Standards
- MailChimp's Email Design Guide
\>\> Return to Table of Contents
$3
- ES6+ Features
- Overview of ECMAScript 6 features
- Babel REPL / ES6 New Features Comparison
- Intro to ES6+
- Dr. Axel Rauschmayer's blog
- Exploring ES6
- Exploring ES2016 and ES2017
- ES6 In Depth
- Nicholas C. Zakas's Understanding ECMAScript 6
- Re-intro to JS
- Articles
- MDN
- A re-introduction to JavaScript (JS tutorial)
- Equality comparisons and sameness, Data types and data structures, Closures, Inheritance and the prototype chain
- Concurrency model and Event Loop, Memory Management
- Dmitry Soshnikov
- JavaScript. The Core
- ECMA-262-3 in detail
- Execution Contexts, Variable object, This, Scope chain, Functions, Closures, Evaluation strategy
- OOP: The general theory, ECMAScript implementation,
- ECMA-262-5 in detail
- Properties and Property Descriptors, Strict Mode
- Lexical environments: Common Theory, ECMAScript implementation
- Notes
- Equality operators, Default values of parameters
- Dmitri Pavlutin
- equality operator, undefined
- variables hoisting, variables lifecycle
- declare functions, 'this' keyword
- three dots
- array creation, object literals
- well-known symbols
- small and plain functions
- unicode
- Other
- The Evolution of JavaScript Modularity
- About object-oriented design and the “class” & “extends” keywords in ES6
- JavaScript Regular Expression Enlightenment
- Books
- Eloquent JavaScript
- Speaking JavaScript
- You Don't Know JS (book series)
- Reference
- JavaScript Guide
- JavaScript Reference
- Important Proposals
- ESM (ECMAScript Modules)
- Intro
- The state of JavaScript modules
- ECMAScript 6 modules: the final syntax
- ES6 Modules in Depth
- Browsers
- ECMAScript modules in browsers
- Node.js
- Node.js, TC-39, and Modules
- .mjs
- Using ES modules natively in Node.js
- esm
- ES Modules in Node Today!
- Dynamic Import (
import())
- Class Fields & Static Properties
- Decorators
- async/await, Promise, Promise Promote, Promises/A+
- Observables
- Static Typing
- Concurrent JS / Parallel JavaScript
- Concurrent JavaScript: It can work!
- The Path to Parallel JavaScript
- A Taste of JavaScript’s New Parallel Primitives
- A cartoon intro to ArrayBuffers and SharedArrayBuffers
- Functional Programming
- Functional Programming for JavaScript People
- Functional Programming Jargon
- Composing Software
- Books
- Professor Frisby's Mostly Adequate Guide to Functional Programming
- Functional-Light JavaScript
- Lodash's FP Guide
- Introduction to Immutable.js and Functional Programming Concepts
- Why Ramda?
- The Philosophy of Ramda
- Favoring Curry
- Thinking in Ramda
- Fantasy Land
- From Callback to Future -> Functor -> Monad
- ADT (Algebraic Data Types)
- JavaScript and Type Thinking
- Functors, Applicatives, And Monads In Pictures
- FRP (Functional Reactive Programming)
- The introduction to Reactive Programming you've been missing
- How Is Reactive Different From Procedural Programming?
- A General Theory of Reactivity
- Learn RxJS
- Rx Book
- Functional Programming in JavaScript
- RxMarbles
- Static Typing
- Intro
- Why use static types in JavaScript?
- You Might Not Need TypeScript (or Static Types)
- Flow
- Flow Runtime
- Flow Comments
- TypeScript
- TypeScript Playground
- DefinitelyTyped, TypeSearch
- tcomb
- JSDoc Tags
- jsdoc-to-assert
- Concurrent JS / Parallel JavaScript
- Napa.js
- Code Style
- Airbnb JavaScript Style Guide
- Node.js Style Guide
- Clean Code JavaScript
- JavaScript Clean Coding Best Practices
\>\> Return to Table of Contents
$3
- References
- WebAssembly.org
- MDN docs
- Concepts
- WebAssembly High-Level Goals
- Minimum Viable Product
- WebAssembly concepts
- An Abridged Cartoon Introduction To WebAssembly
- Features
- Features to add after the MVP
- WebAssembly proposals
- Workshop
- Codelabs - An Introduction to Web Assembly
- Languages
- Rust
- Rust and WebAssembly
- The Rust Wasm Book
$3
- Intro
- The Art of Node
- You Don’t Know Node
- RisingStack's / NodeSource's Understanding the Node.js Event Loop
- Node.js Garbage Collection Explained
- Stream Handbook
- A Brief History of Node Streams
- Understanding Object Streams
- Keeping the Node.js core small
- Debugging Node.js with Google Chrome
- Add v8_inspector supports
- How to Debug Node.js with the Best Tools Available
- Workshop
- NodeSchool
- learnyounode
- Best Practices
- The Node Way
- Joyent's Production Practices - Design, Error Handling
- Best Practices for Node.js Development
- Node.js Best Practices
\>\> Return to Table of Contents
$3
- Web
- Platform Status
- Can I Use
- Chrome, WebKit, Firefox, Edge, TBS (China)
- Platform Releases
- Chrome, Safari (Webkit), Firefox, Edge
- Platform Updates
- Mozilla Hacks
- Web Updates, Chromium Blog
- Webkit Blog
- Microsoft Edge Dev Blog
- Writing forward-compatible websites
- Polyfill - What is a Polyfill?
- Feature Detection - Modernizr/feature-detects, feature.js
- Browser/Device/Runtime Detection - see _Platforms and Languages > Universal Utility Libraries > Parsing / Manipulating_
- Graded Browser Support - Grade components, not browsers
- CSS Support Guide for Email Clients / Email Client CSS Support
- Email Design Reference + HTML Email Templates
- Node.js
- Platform Releases
- Node.js Release Working Group
- ECMAScript Support
- ECMAScript compatibility table
- Node.js ES2015+ Support
- Node 10.x LTS - Supports ES modules natively (without
--experimental-modules)
- Node.8.5 - Supports ES modules natively (
.mjs + --experimental-modules)
- Node 8.3 - V8 6.0, Ignition + Turbofan launched
- Node 8.0 LTS - V8 5.8, Five New Features You Need To Know
- Node 7.6 - V8 5.5, Async functions
- Node 6.0 LTS - V8 5.0, 93% of ES6 language features
- Performance - Six Speed
- Proposal Status
- W3C WG (World Wide Web Consortium Working Groups)
- Web Platform Publication Status
- JavaScript APIs, Mobile Web Applications, CSS
- CSS current work
- Current HTML5 Specifications
- Inside
- W3C TR (Technical Reports)
- An Inside View of the CSS Working Group at W3C
- WICG (Web Incubator Community Group)
- Proposals
- WHATWG (Web Hypertext Application Technology Working Group)
- WHATWG Live Standards
- Inside
- W3C vs. WHATWG HTML5 Specs – The Differences Documented
- ECMA TC39 (Ecma International Technical Committee 39)
- Status, process, and documents for ECMA262
- ECMAScript Proposals / TC39 Proposals
- Inside
- The TC39 Process / The TC39 process for ECMAScript features
- Node.js TSC (Node.js Foundation Technical Steering Committee)
- Meeting Notes
- Inside
- How Node.js created a model open source community
- Healthy Open Source
- JS Engine
- A Guide to JavaScript Engines for Idiots
- V8
- How the V8 engine works?
- Internal
- v8: a tale of two compilers, \
A tour of V8: full compiler
- A tour of V8: Garbage Collection
- Next Generation
- Ignition + TurboFan launch and Declarative JavaScript
- Launching Ignition and TurboFan
- A tale of TurboFan
- Ignition + TurboFan and ES2015
- JSC
- JavaScriptCore, the WebKit JS implementation
- Internal
- Introducing the WebKit FTL JIT
- Next Generation
- JSC Love ES6
- Introducing the B3 JIT Compiler
- Chakra
- Microsoft Edge’s JavaScript engine to go open-source
- Architecture Overview
- Node-ChakraCore and VM Neutrality in Node.js
- Internal
- JavaScript performance updates - 2015, 2016, 2017
- Next Generation
- Roadmap
- SpiderMonkey