- VanJS
- nano JSX
- Tauri #desktop
- Shoelace #web components
- NeutralinoJs
- Frogger in Hyperapp
- How I built super fast JS framework
- Getting started with ReasonML
- HyperApp: The 1 KB JavaScript Library for Building Front-End Apps
- Marko
- Nodes #visual programming
- Radi.js
- Reason
- RE:DOM
- StackBlitz[playground][react][angular][ionic][vscode]
- RunKit
- HyperApp
- Codesandbox[playground][react]
- Svelte
- inferno[react][component][lib]
- Popper.js
- The JavaScript DOM Manipulation Handbook
- Developer Experience - Addy Osmani
- Great (and Free!) Web Development Books You Can Get Online
- Every Layout #css
- Vue Tips Collection
- The TypeScript Handbook
- Human Redux #react
- SurviveJS - Webpack Book
- SurviveJS - React Book
- SurviveJS - Maintenance Book
- Serverless Handbook
- Tackling TypeScript: Upgrading from JavaScript - Dr Axel Rauschmayer
- Deep JavaScript: Theory and techniques - Dr Axel Rauschmayer
- 7 Essential Books For Web Developers
- leonardomso/33-js-concepts
- The Twelve-Factor App[architecture]
- The Offline Cookbook
- Exploring ES2018 and ES2019
- Top 10 JavaScript Books 2019
- Front-End Developer Handbook 2018
- React in patterns
- The JavaScript Way
- Exploring ES2016 and ES2017 - Dr. Axel Rauschmayer
- Babel Handbook
- Setting up ES6 - Dr. Axel Rauschmayer [webpack][babel]
- Mostly adequate guide to FP (in javascript)
- Functional-Light JavaScript
- Functional Programming in JavaScript
- DevFreeBooks
- Exploring ES2016 and ES2017 - Dr. Axel Rauschmayer
- Exploring ES6: Upgrade to the next version of JavaScript - Dr. Axel Rauschmayer
- Programming JavaScript Applications - Eric Elliot
- Learning JavaScript Design Patterns - Addy Osmani
- Eloquent JavaScript 2nd Edition
- https://frontendfront.com
- Sindre Sorhus[links][collection]
- How to keep updated with the JavaScript ecosystem?
- My Front End Reading List
- Frontend Masters #paid
- Vue Mastery #paid #free
- The Gymnasium #free
- Front End Tables: Sorting, Filtering, and Pagination #tutorial
- SEO for Devs – Free 2-Week Course #SEO
- Knights if the Flexbox Table
- Creating An Accessible Dialog From Scratch
- How To Learn Stuff Quickly
- Codewell #challenges
- DOM Events
- 40 JavaScript Projects for Beginners – Easy Ideas to Get Started Coding JS
- Yare #game
- Frontend Masters Learning Roadmap
- JavaScript Questions
- Code Jam[learning][competition]
- Codewars[learning][training]
- Project Euler[mathematical problems][computer programming problems]
- 30 Seconds of Code
- Learn JavaScript
- The secret to being a top developer is building things! Here’s a list of fun apps to build!
- The Modern JavaScript Tutorial
- Learn to Code by Making Games (2D & 3D)
- Frontend Development
- spellbook-of-modern-webdev
- Keeping up with Front-end development
- JavaScript The Right Way [guide]
- 11 JavaScript Blogs to Follow in 2017
- Top JavaScript Frameworks & Topics to Learn in 2017
- 6 Quick & Proven Tips to Help You Learn JavaScript
- 3 Different Kinds of Prototypal Inheritance: ES6+ Edition [delegation][inheritance][mixin][composition][stamp]
- Essential JavaScript Links
- Learn JavaScript Essentials (for all skill levels)
- The Two Pillars of JavaScript: Part 1, [Part 2](https://medium.com/javascript-scene/the-two-pillars-of-javascript-pt-2- p-programming-a63aa53a41a4#.4ee30dr4p) [oop][fp]
- The Single Biggest Mistake Programmers Make Every Day
- Common Misconceptions About Inheritance in JavaScript
- Solving the Josephus problem in JavaScript
- Implementing The Sieve Of Eratosthenes in JavaScript[prime]
- Every job interview has a Q&A
- CV/Resume checkup - Kelly Vaughn
- Interview Officer: "Tell me about Cookies Session and Tokens". Me: "Emm..."
- 10 Common JavaScript Interview Questions (and Answers)
- Top 10 JavaScript Interview Questions
- Tough Questions You Should Always Ask a Hiring Manager
- Deep dive into an interview question: Array Nesting
- JavaScript Interview Prep Cheatsheet – Ace Your Coding Interviews with These Concepts
- JS is Weird #test
- 7 GitHub Repositories To Help You Crush Your Job Interviews
- List of Github repositories - Sunil Kumar
- 10 Most Asked Questions About JavaScript
- Finding the REAL shortest path in JavaScript: Depth First Search
- JavaScript Interview Questions — Objects
- Airbnb Coding Interview Questions
- Top CSS Interview Questions and Answers
- 47 behavioral interview questions and tips to nail your onsite
- 7 Simple but Tricky JavaScript Interview Questions
- TypeOfNaN JavaScript Quizzes
- How to Beat 5 Common JavaScript Interview Challenges
- Rethinking how we interview in Microsoft’s Developer Division
- Front end interview preparation guide
- Tech Interview Handbook
- How the Internet works for a Front-End Developer
- Clearing your Front End Job Interview — JavaScript
- Master the JavaScript Interview: Soft Skills
- Interview Algorithm Questions in Javascript() {...} [interview]
- 14 Events JavaScript Developers Should Attend In 2018
- https://css-tricks.com/guide-2017-conferences/
- JavaScript conferences you can look forward to in 2017
- ECMAScript 2024 feature: Promise.withResolvers()
- ECMAScript 2024 features: resizing and transferring ArrayBuffers
- JavaScript Signals standard proposal
- Understanding Short Polling, Long Polling, Server Sent Events and Web Sockets
- You’ve Got Options for Removing Event Listeners
- Mastering DOM manipulation with vanilla JavaScript
- Cleaning up import paths in JS/TS packages #paths #tsconfig #typescript #alias
- JavaScript waitFor Polling
- What is a CDN? An Unbiased Guide to Content Delivery Networks
- Import maps spec
- JavaScript Import maps, Part 1: Introduction
- Deep Cloning Objects in JavaScript, the Modern Way
- Ecma International approves ECMAScript 2022: What’s new?
- AbortController is your friend
- A pipe operator for JavaScript: introduction and use cases
- A Hands-on Introduction to Fine-Grained Reactivity
- Progressively enhance for a more resilient web
- Modern client-side routing: the Navigation API
- Astro 1.0 #framework #island
- Code Golfing Tips & Tricks: How to Minify your JavaScript Code
- ECMAScript Pattern Matching
- Awesome Bun
- Node.js: checking if an ESM module is “main”
- Everything You Need to Know About JavaScript Import Maps
- JavaScript Records & Tuples Proposal
- A New Pattern For The Jamstack: Segmented Rendering #ssr #csr #ssg
- Never Use JSON.stringify() to Achieve Deep Copy. There is a Huge Pitfall.
- Executing shell commands from Node.js
- Precise Timing With Web Animations API
- State Management: How to tell a bad boolean from a good boolean
- Patterns for Building JavaScript Websites in 2022
- Logging Solutions for Node.js
- Code Reviews 101 - The Basics
- How to design better APIs
- What are wrapper objects for primitive values?
- The Complete Guide to Localizing your App with JavaScript's Internationalization API #localization #internationalization #i18n
- 45 Front End Developer Tools
- JavaScript: What is the meaning of this?
- Debugging JavaScript
- How to Copy to Clipboard in JavaScript with the Clipboard API
- free-for.dev
- Trie in Javascript: the Data Structure behind Autocomplete
- Stop using loading spinners
- Google Chrome Hidden Features Every Developer Should Know #debug
- Your dark mode toggle is broken
- An Intro to JavaScript Proxy
- Currency Calculations in JavaScript
- What’s New With DevTools: Cross-Browser Edition
- Threats of Using Regular Expressions in JavaScript
- ES2022 feature: class static initialization blocks
- An Introduction to JQ #json #query
- Everything You Ever Wanted to Know About WebRTC
- JavaScript Promises: then(f,f) vs then(f).catch(f)
- Building A Dynamic Header With Intersection Observer
- How to convert arrays to human-readable lists in JavaScript
- The Ultimate Guide to Browser-Side Storage
- Detecting media query support in CSS and JavaScript #CSS #media query
- 8 Must-Have ESLint Plugins for your Node.js Application
- Why is NanoID Replacing UUID?
- How to Cancel Pending API Requests to Show Correct Data #AbortController
- Encoding data for POST requests #URLSearchParams #FormData
- Common Documentation Mistakes and How to Avoid Them
- Creating websites with prefers-reduced-data
- Uncaught errors in Node.js and the browser
- How JavaScript works: 3 types of polymorphism
- Declarative Shadow DOM #SSR
- 5 Different Tools for Frontend Monitoring
- JavaScript: How Line Breaks and Missing Semicolons Can Break Your Code
- You don't know the classNames library #CSS
- Import Maps Release & Module CDN Launch
- Looks Good To Me: Making code reviews better for remote-first teams
- Chrome Extension Tutorial: How to Pass Messages from a Page's Context
- How to display dates in your user's time zone with the Intl API
- Zero Server: Build Modern Web Apps with Multiple Languages and Frameworks — and Zero Config
- Sick of the stupid jokes? Write your own arbitrary-precision JavaScript math library[tutorial]
- The Fetch API Cheatsheet: Nine of the Most Common API Requests
- Pattern Matching in JavaScript[switch]
- Declarative Shadow DOM
- Bringing Modern JavaScript to Libraries
- What Is Canary Deployment?
- How JavaScript Works: Under the Hood of the V8 Engine
- Natively Format JavaScript Numbers
- Natively Format JavaScript Dates and Times
- 23 Insanely Useful NodeJs Libraries You Should Know in 2020
- ES2020: Everything You Need to Know
- how to manage HTML DOM[native api]
- How to Cancel a Fetch Request[fetch][abortcontroller][AbortSignal]
- Abortable fetch[AbortController][abortsignal]
- Javascript Proxies : Real World Use Cases
- Debounce vs Throttle: Definitive Visual Guide
- Modern browser APIs to use today
- Introducing Alpine.js: A Tiny JavaScript Framework
- Lazyload images the browser way
- Managing Cyclomatic Complexity
- Stop using isLoading booleans[state enum]
- Angular vs React vs Vue: Which Is the Best Choice for 2020?
- 10 Useful Web APIs for 2020
- The ultimate guide to iframes
- 10 Chrome Console Utility APIs You Probably Never Used
- Deep dive into ES6 Symbols
- 6 Handy Regular Expressions Every Front-End Developer Should Know
- Generate Unique Id in the Browser Without a Library
- The 10 most popular coding challenge websites for 2020[challenge]
- Understand the Nullish coalescing operator coming in ES2020
- 5 things you don’t know about try-catch-finally in JavaScript
- Detect Function Argument Names with JavaScript
- Clean Code Applied to JavaScript:
- Attributes of object properties in JavaScript
- 34 Tips To Become a First-Rate Software Developer
- Understanding the Delete Operator in JavaScript
- When to Use Map instead of Plain JavaScript Object
- Creating custom JavaScript syntax with Babel
- Top JavaScript Maps API and Libraries
- JavaScript Iterators and Generators: Synchronous Generators[generator]
- Why I like JavaScript Optional Chaining
- ES proposal: optional chaining
- How to resume the flow inside a failed try block computation without algebraic effects[tutorial]
- Interesting use cases for JavaScript bitwise operators
- Beyond cookies: Today’s options for client-side data storage
- tc39/proposal-optional-chaining
- ES proposal: private class fields
- Keeping things fresh with stale-while-revalidate
- Weak references and finalizers
- Understanding Web Share APIs
- Hands-on with Portals: seamless navigations on the Web
- A horrifying globalThis polyfill in universal JavaScript
- Data Structures and Algorithms using JavaScript
- 8 time complexities that every programmer should know
- 8 time complexities that every programmer should know
- New JavaScript Features That Will Change How You Write Regex
- Convert a String to a Number in JavaScript
- How to Stop Using Browser Dev Tools and Start Using Your Editor’s Debugger[vscode]
- Lazy Loading with the IntersectionObserver API
- New ES2018 Features Every JavaScript Developer Should Know
- How To Properly Handle Your User’s Passwords
- Bad UX in Web Apps that Perform Intensive Tasks (and How to Avoid it with Queues)
- Creating and filling Arrays of arbitrary lengths in JavaScript
- The Chronicles of JavaScript Objects
- An Open Letter to JavaScript Leaders Regarding Semicolons [semicolon]
- JavaScript Semicolon Insertion Everything you need to know [semicolon]
- Object.fromEntries
- Static Properties in JavaScript Classes with Inheritance
- Copying objects in Javascript
- Should You Use Accelerated Mobile Pages ⚡ (AMP)? What is Wrong 💩 With AMP and What Can You Do To Improve 📈 Your Site
- Drag and Drop It Like It’s Hot: Setting Up the Ultimate Gestures Glamour
- The Front-End Checklist
- ES6 Destructuring: The Complete Guide
- Accessing the Clipboard in JavaScript Using the Async Clipboard API
- These 6 essential tools will release, version, and maintain your NPM modules for you
- Lazy Loading Images and Video #loading #IntersectionObserver
- Time-saving Chrome DevTools Shortcuts
- Master the JavaScript Interview: What’s the Difference Between Class & Prototypal Inheritance?
- How to Handle Monetary Values in JavaScript[money]
- What are JavaScript Generators and how to use them
- How JavaScript works: tracking changes in the DOM using MutationObserver
- Here’s everything I’ve learned from designing 10,000+ UI screens as a lead product designer
- ECMAScript 6 - Reflect
- Top 50 Developer Tools of 2017
- Observe changes in DOM using MutationObserver
- Working with the new CSS Typed Object Model
- Accessing the DOM is not equal accessing the DOM – live vs. static element collections
- Cool Chrome DevTools tips and tricks you wish you knew already
- JavaScript Modules Worth Using
- Best practices on how to work with collections in Javascript
- await vs return vs return await
- 30 Seconds of Code
- How GDPR Will Change The Way You Develop[gdpr]
- Multiple Inheritance in JS
- Please Stop Using Local Storage
- Ways to Use Javascript to Redirect to Another Page
- JavaScript Decorators for Declarative and Readable Code
- Regular Expressions Demystified: RegEx isn’t as hard as it looks[regexp]
- Modern Front-End Frameworks should be less of a “frame” and more of a “work”
- 10 Tips for Javascript Debugging Like a PRO with Console
- How to debug Front-end: Console
- async/await: It’s Good and Bad
- A gentle Introduction to Ajax.[ajax]
- The Front-End Checklist
- The 14 JavaScript debugging tips you probably didn't know[debug]
- Here is what you need to know about JavaScript’s Number type
- Tasks, microtasks, queues and schedules[event loop]
- Typing import statements more quickly
- JavaScript Events Unmasked: How to Create an Input Mask for Mobile[mask][android][mobile][key handling]
- Beyond typeof and instanceof: simplifying dynamic type checks
- The State of Internationalization in JavaScript
- How writing custom Babel & ESLint plugins can increase productivity & improve user experience
- The Ultimate Guide to JavaScript Fatigue: Realities of our industry
- Composing regular expressions via re-template-tag [regexp]
- How to retrieve images from the clipboard with JavaScript in the Browser
- 6 Tips and Best Practices for Great Mobile Design
- Refactor Code in Your Lunch Break: Getting Started with Codemods
- Communicating Sequential Processes: an alternative to async generators [CSP]
- Compile JavaScript? Really?
- The Definitive Guide to DateTime Manipulation
- How To Check If Javascript Event Was Triggered By Human
- Copying to Clipboard Using Vanilla JavaScript[copy]
- Copy To Clipboard in JavaScript[copy]
- JavaScript APIs: Console
- Three Rules For Structuring (Redux) Applications [react][redux][project structure][organization]
- How tabs should work
- Native JavaScript Development after Internet Explorer
- Web Developer Checklist
- oxlint
- knip #maintainability #cleanup #unused
- Signia #signals #react
- devalue #JSON.stringify #JSON.parse
- WebContainers
- Astro
- Bun #JavaScript runtime
- What the f*ck JavaScript?
- Plasmo #browser extension
- MicroDiff
- filesize.js
- Threads.js
- fx #json
- zx
- Gitlet #git
- patch-package #avoid fork
- classNames
- Zero Server, remoteinterview/zero
- winston
- detect-es-version
- devcert
- jquense/yup[schema validation]
- Fuse.js
- developer-roadmap
- javascript-algorithms
- app-ideas
- project-guideline
- Best-websites-a-programmer-should-visit
- free-programming-books
- awesome-learning-resources
- licia
- luruke/browser-2020
- klona[deep clone][clone]
- humanwhocodes/computer-science-in-javascript
- haiku.ai/
- prismjs.com/
- docusaurus.io/
- gruns/ImmortalDB[cookie][localstorage][sessionstorage][indexeddb]
- github/hotkey
- Awaity.js
- Nothing[maybe like]
- HotKeys.js
- clean-code-javascript
- hapijs/bounce
- What Web Can Do Today
- Front End Checklist
- Slim.js
- Text Mask
- morphdom
- Nano ID
- RealWorld
- js-joda
- Collections.js
- Moment.js
-
Luca Mezzalira – Micro frontends anti patterns | Øredev 2022
-
You Don't Need Another Library to Compose Micro Frontends at Run Time
-
5 Different Techniques for Cross Micro Frontend Communication
-
Module Federation Shared API #webpack
-
Addressing Micro Frontend Criticisms & Environmental Differences
-
Yoav Yanovski - Micro Frontends: Composing a Greater Whole - Vue.js Amsterdam 2020
-
Revolutionizing Micro Frontends with Webpack 5, Module Federation and Bit[webpack]
-
Independent micro frontends with Single SPA library[single-spa]
-
Building Micro Frontends with React, Vue, and Single-spa[single-spa]
-
Micro-frontend Architecture: Replacing a Monolith from the Inside Out
-
Micro Frontend Architecture: Import chunks from another Webpack bundle at runtime[webpack]
- VueMS (Vue Micro Services) #vue #nuxt
- MicroLib
- awesome-microfrontends
- Piral
- Luigi
- Open Components
- PostMate
- Web Components
- Puzzle.js
- Ara Framework
- Podium
- Project Mosaic
- Bit
- single-spa
- Frint.js
- tailor
- h-include.js
- hinclude.js
- SEO for JavaScript-heavy websites
- Optimize SEO and Social Media Sharing in a Nuxt blog
- A Practical Guide to Search Engine Optimization (SEO) with Google
- Optimizing Javascript for fun and for profit
- Inspect Source Code Performance with Deoptigate
- The truth about CSS selector performance
- Ryan Florence Tweet #CLS #lazy #webp
- Why Your Cached JavaScript Is Still Slow and Incurs Performance Overhead
- Measuring web performance, How fast is fast?
- How Partytown Eliminates Website Bloat From Third-Party Scripts
- Optimising Core Web Vitals on SPAs #LCP #CLS #FID #TBT
- Optimising Largest Contentful Paint
- Front-End Performance Checklist 2021
- Explore JavaScript Dependencies With Lighthouse Treemap
- Loading Third-Party JavaScript
- 8 Performance Analysis Tools for Front-End Development
- Why lab and field data can be different (and what to do about it)
- How to load a CSS file async
- Serving sharp images to high density screens #image #screen density #dpr #dppx
- The Humble
Element And Core Web Vitals
- Building a Faster Web Experience with the postTask Scheduler
- 5 steps to faster web fonts
- Optimizing Web Vitals using Lighthouse
- Top Metrics You Need to Understand When Measuring Front-end Performance
- Web Performance Recipes With Puppeteer
- Enabling faster SPA navigation with Turbolinks
- Thoughts on device based code split in React
- Faster Web App Delivery with PRPL
- Reducing the Site-Speed Impact of Third-Party Tags
- Optimized media loading using Web Workers
- Preload, Prefetch And Priorities in Chrome
- 5 tricks to eliminate render blocking resources
- An Introduction To Running Lighthouse Programmatically
- radEventListener: a Tale of Client-side Framework Performance
- It's time to lazy-load offscreen iframes!
- Preloading responsive images
- Optimize for Core Web Vitals[video]
- Rendering on the Web[SSR][csr][Prerendering][seo]
- In the name of SEO: Server-side rendering for single-page apps[SSR][csr][Prerendering][seo]
- Why do we love Isomorphic/Universal rendering?[ssr][csr][SEO]
- Advanced Server-Side Rendering With Laravel & Vue: Multi-Page App[ssr][seo]
- Is My Single-Page Application SEO Friendly?[SSR][csr][Prerendering][seo]
- Web Vitals - Essential metrics for a healthy site[LCP][fid][CLS]
- Accurately measuring layout on the web
- Is postMessage slow?[web worker]
- Taming huge collections of DOM nodes
- 17 JavaScript / node.js performance coding tips to make applications faster
- Isolating memory leaks with Chrome’s Allocation Timeline
- How JavaScript works: memory management + how to handle 4 common memory leaks
- The Critical Request
- Improving Web Performance to Mirror Engine Speed
- Improving App Startup Time on Android with Webpack + V8 Heap Snapshot
- 14 Important Website Performance Metrics You Should Be Analyzing
- Basics of Front-End Performance Tuning
- JS Mythbusters
- Improving Performance with Cache-Control: Immutable
- Performance Testing with the User Timing API
- Asynchronous vs Deferred JavaScript [html][script][async][defer]
- How I wrote the world's fastest JavaScript memoization library
- React at 60fps [react]
- Optimization killers
- 10 things I learned making the fastest site in the world
- KV.JS #cache
- ai/size-limit #statoscope
- vanilla-lazyload
- lazysizes
- Squoosh
- Yellow Lab Tools
- Clinic.js Doctor
- Turbolinks
- Perfume.js
- Quicklinks[prefetch]
- Web Vitals Chrome Extension
- lighthouse
- WebPagetest
- ngrok // share localhost stuff via tunneling
- Parsing command line arguments with util.parseArgs() in Node.js
- Using web streams on Node.js
- Node.js: creating ESM-based shell scripts for Unix and Windows
- Working with file system paths on Node.js
- Working with the file system on Node.js
- Best Tricks to Make Your Node.js Web App Faster
- JavaScript for Data Science
- Top 12 JavaScript Machine Learning Libraries for 2020
- TensorFlow.js: An intro and analysis with use cases
- How to Use Machine Learning in Marketplace Development
- Kalimdor.js: Machine Learning with TypeScript
- The Ultimate Guide on Deep Learning for web developers
- 11 Javascript Machine Learning Libraries To Use In Your App
- 5 Ways to Get Started with Machine Learning
- Machine Learning with JavaScript
- 10 Machine Learning Examples in JavaScript
- astorfi/TensorFlow-World[tutorial]
- tfjs
- Probot
- FracturedJson #formatter
- HTML Sanitizer API #sanitize
- https://www.sitepoint.com/dom-manipulation-vanilla-javascript-no-jquery/
- Convert String to DOM Nodes
- DOMPurify #sanitize
- Creating an accessible autocomplete experience
- Access Guide
- Accessibility Testing with pa11y
- 10 guidelines to improve your web accessibility
- 9 tips to get bare minimum of web accessibility
- Writing JavaScript with accessibility in mind
- Accessibility Basics: Designing for Visual Impairment
- Password Management: Passwordless Login
- Password Management: The Basics
- Node.js Security Best Practices #node.js
- Cory House: 2022 Frontend security in 1 tweet
- What's Really Going On Inside Your node_modules Folder?
- Web Authentication: Cookies vs. Tokens
- Dealing with some CSRF attacks using the SameSite cookies
- JavaScript Security Issues and Best Practices
- Web Application Security Practices Every Developer Must Know[OWASP]
- How to Hide Secrets in Strings— Modern Text hiding in JavaScript
- Authentication on the Client Side the Right Way: Cookies vs. Local Storage
- Authentication & Authorization in Web Apps
- Passwords are Obsolete — How to Secure Your App and Protect Your Users
- CS 253 Web Security[course]
- Tracking Users with CSS
- Defensive JavaScript
- Pros and cons in using JWT (JSON Web Tokens)
- Protect your Node.js app from Cross-Site Request Forgery
- Third party CSS is not safe
- Security Checklist for Full Stack Web Developers part 1 part 2
- Best solutions for keeping JavaScript clean and secure
- Quick Intro to the Payment Request API
- How to Get Started with Your Website Content Security Policy
- Stop Paying for SSL Certificates [ssl]
- Accept payments on your site with NextJS, Stripe, and Micro
- A Guide to Security Best Practices for Remote Teams
- How To Secure Your Web App With HTTP Headers
- Preventing cross-site attacks using same-site cookies [csrf]
- Web security essentials - Password storage
- The Most Common XSS Vulnerability in React.js Applications [xss][react]
- Immutable.js, persistent data structures and structural sharing
- You’re missing out on ImmutableJS Records
- The Missing Immutable.js Manual with all the Examples you’ll ever need
- Embracing Immutable Architecture [react][redux] [elm]
-
Elm - Franzé Jr.
-
James Kolce
-
Introduction Into Elm
- Encoding HKTs in TypeScript (Once Again) #higher kinded types
- Typescript code with and without Effect
- Complete introduction to using Effect in Typescript
- Making Curry: JavaScript Functional Programming
- Functional Reactive Programming with SolidJS and fp-ts
- JavaScript function composition: What’s the big deal?
- Mutative - 10x faster than Immer #immutable
- What’s so great about functional programming anyway?
- Why would anyone need JavaScript generator functions?
- Functional Programming Jargon
- Functional Programming 101
- Higher-Kinded Data in TypeScript
- Intro to fp-ts, part 1: Higher-Kinded Types
- Intro to fp-ts, part 2: Type Class Pattern
- Intro to fp-ts, part 3: Option and Either
- Intro to fp-ts, part 4: Tasks as an alternative to Promises
- Introduction to the Solid JavaScript Library
- RxJS Operators In-Depth - Part 1
- Cube Composer[game]
- A fool's scriptum on functional programming[course]
- Thoughts on Railway Oriented Programming — JavaScript[either]
- How to not create your RxJS observables[rxjs]
- Lambda Calculus - Computerphile
- An introduction to Lambda Calculus, explained through JavaScript
- Functional Programming for JavaScript Developers Immutability and Pure Functions Currying Compose Map Safe Containers in JavaScript Type Signatures Introduction to Algebraic Structures
- kongware/scriptum
- Promise Lifting: A new async coding technique
- What's Happening With the Pipeline (|>) Proposal?
- Currying in JS: Answering the traditional question, Add(2)(3), which gives sum of both numbers.
- An Informal Exploration of Structural Sharing, Proxies, and Copy-on-Write Semantics[tutorial]
- Observables, Side-effects, and Subscriptions[rxjs]
- Reactive Programming in JavaScript with RxJS
- Functional Programming Exercises in Javascript
- Composable, Immutable property access with Lenses in Typescript
- Master the JavaScript Interview: What is Functional Programming?
- Marble testing Observable Introduction[rxjs]
- Alternative to JavaScript’s switch statement with a functional twist
- Get to know the Actor Model[actor]
- The Perfect API[task][maybe][either][lift][ap][of]
- Javascript without loops[array][map][filter][reduce][novice]
- The versatility of Array methods[array][maybe]
- Why Ramda?
- A gentle introduction to functional javascript - James Sinclair part 1 part 2 part 3 part 4
- The marvellously mysterious javascript maybe monad[maybe][monad][promise]
- Folding Promises in JavaScript[promise][lift]
- Lifting functions into monadic Context in JavaScript[maybe][lift][monad]
- Functions as Functors
- Yippee Ki-Yay, All the Functors!
- flat-map
- Functional pattern: flatMap
- Monads in JavaScript
- Why use a Maybe type in JavaScript? [maybe]
- Fantas, Eel, and Specification (Tom Harding)
- Composing Software (Eric Elliott)
- "Book"
- An Introduction
- The Dao of Immutability: The Way of the Functional Programmer
- The Rise and Fall and Rise of Functional Programming
- Why Learn Functional Programming in JavaScript?
- Master the JavaScript Interview: What is a Pure Function?
- A Functional Programmer’s Introduction to JavaScript
- Higher Order Functions
- Reduce
- Curry and Function Composition
- Abstraction & Composition
- Abstract Data Types
- Functors & Categories
- JavaScript Monads Made Simple
- The Forgotten History of OOP
- The Hidden Treasures of Object Composition
- Nested Ternaries are Great
- JavaScript Factory Functions with ES6+
- Functional Mixins
- Why Composition is Harder with Classes
- Composable Datatypes with Functions
- Lenses
- Transducers: Efficient Data Processing Pipelines in JavaScript
- Elements of JavaScript Style
- Mocking is a Code Smell
- Thinking in Ramda
- Safely Accessing Deeply Nested Values In JavaScript [ramda][folktale]
- Casual functional adventures in JavaScript
- Functional Workaholism
- Awesome FP JS
- Functional Programming (FP) By Any Other Name…
- Mori [persistent data structures][clojure]
- Functors encapsulate imperative logic
- If Else vs Either Monad vs FRP
- So You Want to be a Functional Programmer - Charles Scalfani: Part 1, Part 2, Part 3, Part 4, Part 5, Part 6
- effect
- TS-Pattern
- Mutative
- marble
- SolidJS
- mem
- Clio #language
- purify-ts
- mori
- eslint-plugin-fp
- Sanctuary
- Fluture [promise]
- monet.js
- moize [memoize]
- Fantasy Land
- Lazy.js
- Folktale 2.0
- Folktale 1.0
- FPO
- functional.js
- Ramda
- ramda-fantasy [maybe][either][io][monad]
- Understanding Transducers in JavaScript
- Introduction into Channels and Transducers in JavaScript [transducer]
- Generators and Channels in JavaScript [generator][promise][react]
- Taming the Asynchronous Beast with CSP Channels in JavaScript
- Communicating Sequential Processes
- Linters Gonna Lint
- Why aren’t you using Prettier?
- XO
- JavaScript Standard Style
- ESLint
- Principles of Writing Consistent, Idiomatic JavaScript
- Rules For Structuring (Redux) Applications [react][redux] [structure]
- Random notes around service workers development and testing
- Now THAT’S What I Call Service Worker!
- Progressive Web Apps in 2021
- Service Worker Lifecycle Explained
- Understanding Service Workers and Caching Strategies
- A declarative router for service workers
- Service Worker gotchas
- High-performance service worker loading
- Understanding The Service worker LifeCycle
- How to display a "new version available" for a Progressive Web App
- How to use IndexedDB to build Progressive Web Apps
- How JavaScript works: Service Workers, their lifecycle and use cases
- How JavaScript works: the mechanics of Web Push Notifications
- A Simple Guide to Taking a Web Page Offline, using Service Workers[tutorial]
- Minimal viable service worker
- Making our site more app-y
- Yes, That Web Project Should Be a PWA
- Using Google Lighthouse To Enhance Progressive Web Apps
- Progressive Web Apps
- A progressive Web application with Vue JS, Webpack & Material Design: Part 1 Part 2
- Native Apps are Doomed
- Learning Progressive Web App
- How To Strongly Type process.env
- Covariant, Contravariant, and Invariant in Typescript
anyConsidered Harmful, Except For These Cases- Don't use return types, unless...
- Type Predicate Inference: The TS 5.5 Feature No One Expected
- NoInfer: TypeScript 5.4's New Utility Type
- Array vs T[]: Which is better?
- How To Type Array.reduce
- Microsoft: TS Performance
- Method Shorthand Syntax Considered Harmful
- DistributiveOmit
- Type vs Interface: Which Should You Use In 2023?
- Why You Can't Use Dot Notation On Types
- Strongly Type useRef with ElementRef #react
- Explained: Cannot use JSX unless the '--jsx' flag is provided #react
- There Is No Such Thing As A Generic
- TypeScript Generics in 3 Easy Patterns
- How to Iterate Over Object Keys in TypeScript
- Four Essential TypeScript Patterns You Can't Work Without
- Type Argument Placeholders: TypeScript's Most Discussed Upcoming Feature
- The Empty Object Type in TypeScript
- TypeScript 5.2's New Keyword: 'using'
- Get Keys of an Object Where Values Are of a Given Type
- How to Properly Type Window
- Since TypeScript 5.1, React.FC is now "fine" #react
- What is JSX.IntrinsicElements? #react
- Explained: 'React' refers to a UMD global #react
- React.ReactNode vs JSX.Element vs React.ReactElement #react
- Transform Any Union in TypeScript with the IIMT
- Where To Put Your Types in Application Code
- ComponentProps: React's Most Useful Type Helper #react
- How to test your types
- Testing with TypeScript is Painful: Here's a Solution
- Const type parameters bring 'as const' to functions
- 9 ways to use Exclude in TypeScript
- Discriminated Unions are a Frontend Dev's Best Friend
- Clarifying the
satisfiesOperator - Structure of a TypeScript Error
- When should you use Zod? #validation
- Writing string.replace in TypeScript
- Introducing Valibot, a < 1kb Zod Alternative #schema #validation
- Advanced Typescript: Typing Partially Applicable Functions
- TypeScript Advanced Types for Next.js: Examples and Best Practices In 2023
- Compile-time Immutability in TypeScript
- Demystifying Typescript Unions and Intersections
- Types in JavaScript With Zod and JSDoc
- Building Complex Types in TypeScript part1, part 2
- Consistent Type Imports and Exports: Why and How #ESLint #TypeScript
- Prettify
- TypeScript Utility Types You Need to Know
- Fun with Types
- Level TypeScript #tutorial
- TotalTypeScript - Matt Pocock #tutorial
- Use TypeScript Mapped Types Like a Pro
- Extract parameter types from string literal types with TypeScript
- Building attractive CLIs in TypeScript
- The Most Asked TypeScript Questions on StackOverflow – Answered for Beginners
- Introducing Deepkit Framework
- Filtering arrays with TypeScript type guards
- Secrets of ‘never’ Types in TypeScript
- A complete guide to TypeScript’s never type
- Assertion Functions in TypeScript
- How not to learn TypeScript
- How to write a Constrained Identity Function (CIF) in TypeScript
- SnakeToCamel #camelize #snake case
- Mastering TypeScript Template Literal Types
- Covariance and Contravariance in TypeScript
- Index Signatures in TypeScript
- unknown vs any in TypeScript
- Type Guards and Control Flow Analysis in TypeScript 4.4
- TypeScript: Unexpected intersections
- TypeScript: Array.includes on narrow types
- Advanced TypeScript: A Generic Function to Merge Object Arrays
- Tag hierarchies via Template Literal Types
- Starting a TypeScript Project in 2021 #esbuild
- Using TypeScript Project References to share common code
- Build JavaScript applications using TypeScript #course
- The Complete Guide to Immutability in TypeScript
- TypeScript Function Syntaxes
- Using 'Pick' in TypeScript to simplify Types and Interfaces
- Introduction to Index Types in TypeScript
- Boost Your Automated Test Workflow using TypeScript IntelliSense
- TypeScript Typeguard Transparency
- TypeScript: narrowing types via type guards and assertion functions
- How to get the types you want with TypeScript type guards
- Using built-in utility types in TypeScript
- Bringing TypeScript Types at Runtime with TypeOnly
- TypeScript exercises
- Testing Typescript Types
- Computing with types in TypeScript
- The top types any and unknown in TypeScript
- Types for classes as values in TypeScript
- Augmenting Interfaces in the Global Scope in TypeScript
- The Omit Helper Type in TypeScript
- More advanced types with TypeScript generics
- Typescript Generics Discussing Naming Conventions
- Types for classes in TypeScript
- Get rid of relative import path hell by adding absolute imports to your Typescript project
- TypeScript without TypeScript -- JSDoc superpowers[jsdoc]
- Node.js TypeScript: the basics of Node.js
- TypeScript 2.8: Mapped Type Modifiers
- How not to lint your code?[lint]
- The TypeScript Tax
- How TypeScript breaks referential transparency (and what to do about it)
- Data fetching in React the functional way powered by TypeScript, io-ts & fp-ts
- TypeScript 2.8: Conditional Types
- TypeScript — Make types “real”, the type guards
- TypeScript 2.7: Strict Property Initialization
- Understanding TypeScript’s type notation
- A Look at TypeScript's Conditional Types
- Interface vs Type alias in TypeScript 2.7
- Manual Typing is No Fun: Introducing TypeWiz!
- TypeScript 2.4: Spelling Correction
- Pattern Matching with TypeScript
- TypeScript 2.3: Downlevel Iteration for ES3/ES5
- TypeScript 2.3: Type-Checking JavaScript Files with --checkJs
- TypeScript 2.3: The --strict Compiler Option
- TypeScript 2.3: Generic Parameter Defaults
- TypeScript 2.2: Mixin Classes
- Tired of waiting for TypeScript compilation? [isolatedModules]
- TypeScript 2.2: Null-Checking for Expression Operands
- TypeScript 2.2: Dotted Properties and String Index Signatures
- TypeScript 2.2: The object Type
- TypeScript 2.1: Improved Inference for Literal Types
- TypeScript 2.1: Literal Type Widening
- TypeScript 2.1: Untyped Imports
- TypeScript 2.1: Mapped Types
- TypeScript 2.1: External Helpers Library
- TypeScript 2.1: async/await for ES3/ES5
- Announcing TypeScript 2.1
- Typescript decorators
- TypeScript 2.0: Read-Only Properties
- TypeSearch
- How to write multi-module Typescript declaration files
- tsdocs.dev
- Valibot #schema #validation
- shoehorn
- ts-toolbelt
- ArkType
- Higher-Order TypeScript (HOTScript)
- ts-reset
- tRPC #api #typesafe
- Deepkit
- Yup #schema
- Zod #schema
- io-ts #schema
- Ajv #schema
- Runtypes #schema
- tsup
- TypeBox
- airbnb/ts-migrate
- transitive-bullshit/functional-typescript
- TypeWiz
- Introducing Shoelace, a Framework-Independent Component-Based UX Library
- Resumability, WTF?
- Building forms with custom elements
- Fast UI — Build a To-Do App with VanillaJS and Web Components
- Building Interoperable Web Components That Even Work With React
- Why Efficient Hydration in JavaScript Frameworks is so Challenging
- Tailwind UI: Now with React + Vue support
- Headless UI: Unstyled, Accessible UI Components
- Web Components Are Easier Than You Think
- Building a Tabs component
- Sharing reusable Vue.js components with Lerna, Storybook, and npm or GitHub Package Registries
- Sharing UI components at an enterprise level[bit][storybook]
- 6 Ways to Share React Components in 2020[component sharing][microfrontend]
- The rules of reusable components[react]
- Tips and tricks for creating reusable UI components
- Sharing Code Between Projects: Lessons Learned In The Trenches[Bit]
- Structuring projects and naming components in React
- Curated List of Angular, React & Vue.js Resources
- Using Higher Order Components for Authenticated Routing[react]
- How to package your React Component for distribution via NPM[react][npm][publish]
- Developing Apps With Styled-Components[react][styled components]
- How “Controllable” React components maximize reusability
- Simple React Patterns[higher order component][hoc][react]
- Smart and Dumb Components in React
- The 100% correct way to structure a React app (or why there’s no such thing)
- The way of a Higher-Order Component[higher order component][hoc][react]
- React Universal Component 2.0 & babel-plugin-universal-import[react]
- Presentational and Container Components [smart-dumb][stateful-stateless]
- Using Presentational and Container Components with Redux [smart-dumb][stateful-stateless]
- Higher-Order Components in Vue.js [vue]
- Higher-Order Components [react]
- Web Components: How To Craft Your Own Custom Components [webcomponents]
- Introducing React Loadable
- Why use reactive streams for components?
- How to use React’s higher-order components [react]
- Why you should learn the highlights of Angular 1.5 [angular]
- Flattening Deep Hierarchies of Components
- Getting a grip on Nuxt's auto-import functionality
- Modular site architecture with Nuxt layers
- How to deal with caching and dynamic content in Nuxt?
- Introducing @nx/nuxt: Enhanced Nuxt.js Support in Nx
- 7 New Features in Nuxt 3.9
- Nuxt 3.9
- The BEST way to proxy your API in Nuxt
- Nuxt Monorepo for Large-Scale Vue Web Application
- Lazy Hydration and Server Components in Nuxt – Vue.js 3 Performance
- Understanding and Measuring Nuxt Performance – Vue.js 3 Performance
- Nuxt Icon
- A guide to Nuxt server components
-
async components/code splitting
-
Code Splitting With Vue.js And Webpack[webpack][code splitting][async component]
-
3 Code Splitting Patterns For VueJS and Webpack[code splitting]
-
Better Stores in Pinia with Vue3 — Global Stores, Nesting and Accessing Vue Router in Pinia
-
Optimizing Image Integration in Vite with Vue: A Comprehensive Guide
-
Vue.js Nation 2024: Unlocking Reusability Generically Typed Vue.js Components by Abdelrahman Awad #TS #typescript #generics
-
SSR Safe Dynamic IDs in Vue #directive #useId
-
Developing A Vue 3 Headless Component #renderless
-
Vue.js Headless Component #renderless
-
From my point of Vue: Headless components #renderless
-
Composition API v Renderless Components - Let's use Vue 3's features to clean our components! #headless
-
Renderless Components in Vue.js #headless
-
Template literal types in the Vuex #TypeScript
-
Optimizing the Performance of Your Vue Apps Using Web Workers #performance #webworker
-
rendering in Vue to improve performance #IntersectionObserver #requestIdleCallback
-
React Context and Provider Pattern with the Vue 3 Composition API
-
How To Build A Geocoding App In Vue.js Using Mapbox #geocoding #mapbox
-
Top 3 GraphQL Resources for Vue.js Developers in 2021[GraphQL][swr][urql][jwt][Auth0][firebase]
-
Best Static Site Generators for Vue.js[Nuxt][gridsome][VuePress][saber]
-
Lazy-Loading Routes with Vue Router with a Progress Bar[tutorial]
-
Handling Asynchrony with Vue Composition API and vue-concurrency
-
Do Vue 3 refs admit a monad instance?[fp][monad]
-
Testing Vue+Apollo: 2020 edition[apollo]
-
Clean, Scalable Forms with Vue Composition API[validation][composition]
-
Really typing Vue[typescript]
-
Nuxt: The Hard Parts[Nuxt]
-
Lessons Learned on Writing Apps with NativeScript VueJS[NativeScript]
-
Measure runtime performance in Vue apps[performance]
-
30 Days of Vue[learn]
-
Creating Your Own Vue.js Router[tutorial]
-
Renderless Components in Vue.js[slots][hoc][tutorial]
-
Testing Vue web applications with Vuex data store & REST backend[test][cypress][e2e]
-
Autosaving with Vuex[vuex][autosave]
-
Setting up JWT authentication with Laravel and Vue JS - Part 1[jwt][tutorial][authentication]
-
Higher Order Components in Vue.js[hoc][tutorial]
-
Let’s Build a Custom Vue Router [tutorial][route]
-
Creating Reusable Transitions in Vue[animation][transition][reusable]
-
How to Create an Accessible Autocomplete Component with Vue.js[aria][accessibility]
-
Creating a Vue.js Serverless Checkout Form: Setup and Testing[stripe]
-
Dynamic Modules with Vuex and Vue[vuex][dynamic module]
-
Creating Vue.js Transitions & Animation: Live Examples[transition][animation]
-
Testing with Vue.js[test][component][interaction]
-
Don't Forget Browser Button UX In Your Vue.js App[state][routing]
-
Simple Server Side Rendering, Routing, and Page Transitions with Nuxt.js
-
Vue.js’s Single File Components: Keeping It All In One Place [css modules]
-
DejaVue [visualization][time travel]
- radix-vue
- shadcn-vue
- Vitest
- vue-progressive-image #performance
- Vue Intersect
- vue-tiny-lazyload-img #performance
- Vue-Lazyload (v-lazy, v-lazy-container, lazy-component) #performance
- v-lazy-component #performance
- vuex-composition-helpers #TypeScript
- VueDX
- Pinia #state management
- Vue SFC Playground
- vue-promised
- vueuse/motion
- OverVue #prototyping
- urql #GraphQL
- SWRV #SWR #GraphQL
- Vue-Tailwind
- vue-a11y/vue-axe
- ktsn/vue-auto-routing
- ktsn/vue-route-generator
- u3u/vue-hooks
- composition-api
- VueUse[composition]
- vue-composable[composition]
- awesome-vue-composition-api
- Vue Watch
- y-nk/vue-fragment
- chenquincy/vue-dynamic-form-component
- vue-function-api
- vue-observe-visibility[intersection observer]
- Vuefire
- Hooper
- sue71/vuex-typescript-fsa[vuex][typescript]
- alexjoverm/v-lazy-image
- egoist/lit-vue
- vue-datepicker-ui
- vue-inter
- Vuido[desktop]
- vue-coerce-props
- iView
- Vuex Pathify
- VuePress
- Quasar
- vue-enterprise-boilerplate
- vuex-loading
- vuetron
- ream
- Avoriaz
- iview
- vue-rx
- VeeValidate
- Nuxt
- vue-unit
- vetur [vscode]
- Vue Components [vscode]
- Vuetify.js
- Vuelidate
- The Good and Bad of Angular Development
- Techniques for Improving ng-repeat Performance
- Angular 2 Testing In Depth: Services
- Angular 2 — Explore The Renderer Service
- Angular 2 — New features in Angular 2.1
- Simple Pagination for Angular 2 Applications
- Angular 2 form fundamentals: reactive forms
- Angular 2 form fundamentals: template-driven forms
- Angular2 CLI tool
- Functional and reactive programming in Angular 2 [rxjs]
- How to build and deploy a modern-day Next.js application
- Next.js Enterprise Boilerplate
- Things you might not know about Next Image
- Next.js Fetch: The Secret Weapon for Efficient Data Fetching
- EpicWebDev: React Server Components
- Things you forgot (or never knew) because of React
- Headless Component: a pattern for composing React UIs
- Streams—The definitive guide
- The React Handbook
- Everything I wish I knew before moving 50,000 lines of code to React Server Components #RSC
- Effective TypeScript for React Applications
- Using useMutation to make an advanced toggle in React #react query
- Teleportation in React: Positioning, Stacking Context, and Portals
- React Server Components, Next.js App Router and examples
- Grok React Server Component by Quizzes
- Breaking React Query's API on purpose
- Writing Type-Safe Polymorphic React Components (Without Crashing TypeScript)
- React forwardRef(): How to Pass Refs to Child Components
- React Libraries for 2023
- The self-fulfilling prophecy of React
- Your Guide to React.useCallback()
- How to useMemo and useCallback: you can remove most of them
- Understanding useMemo and useCallback
- Practical React Query 1..23
- Five Challenges to Building an Isomorphic JavaScript Library
- Data Binding in React
- Top 7 React Animation Libraries in 2022
- What is React State Management?
- Optimizing Web Fonts in Next.js 13 #Next
- Why We're Breaking Up with CSS-in-JS
- Demystifying styled-components
- Why React Re-Renders
- Ecma International approves ECMAScript 2022: What’s new?
- ES2022 Features!
- React Hooks: The Deep Cuts
- Applying SOLID principles in React
- Statements Vs. Expressions
- The new wave of React state management
- Writing local rules for ESLint #codeshift
- Jamstack Rendering Patterns: The Evolution
- WebGPU — All of the cores, none of the canvas
- How To Use React useRef Hook (with Examples)
- Prefer Declarative State Updaters #useState #hooks
- Understand the JavaScript Execution Mechanism Thoroughly This Time
- Remix vs Next.js
- React Server Components and Remix #render #fetch #performance
- Remix.run
- How to replace useState with useRef and be a winner
- React & TypeScript: how to type hooks (a complete guide) #TypeScript
- Are many useStates better than useState(object)?
- Introducing Sapling, A VS Code Extension For Traversing Your React Component Hierarchy
- Converting a React component to TypeScript
- what's new in react 18?
- React state with a fragmented store
- What the Heck Is Ref Forwarding?
- Using Recoil instead of Redux For State Management In React Applications.
- CSS Variables for React Devs
- Compound Components In React
- Keep the React app responsive even during large screen updates with startTransition API introduced in React 18
- 5 String Manipulation Libraries for JavaScript
- Optimizing React apps: Hardcore edition
- How to Use Promise.allSettled()
- react-tracked - so helpful tool
- Make it work, Make it right and make it better.
- When a Click is Not Just a Click
- 5 Packages to Optimize and Speed Up Your React App During Development
- ECMAScript proposal: Import assertions
- The modern guide to React state patterns #useSWR #redux #xstate
- How to manage global state with XState and React #xstate
- React UI Libraries 2021
- useQuery Instead of Fetch While Calling an API
- Top 10 React Hook Libraries
- 5 Key Lessons React Tutorials Don't Teach
- The Latest Ref Pattern in React #useLayoutEffect #useRef #useEffect #useMemo #useCallback
- useEncapsulation or Why Your React Components Should Only Use Custom Hooks
- How State Works in React – Explained with Code Examples
- React State Management Libraries and How to Choose
- The last guide to the useEffect Hook you’ll ever need
- Why I Stopped Using Redux
- Render props vs hooks
- 3 Rules of React State Management
- Advanced memoization and effects in React
- How to handle async side effects in 2019
- Don't Sync State. Derive It!
- Do React Hooks Replace Redux?
- Effortless render optimization with state usage tracking with React hooks
- setInterval in React Components Using Hooks
- Always useMemo your context value
- Application State Management with React
- The State Reducer Pattern with React Hooks
- Jolly Roger - a 2KB micro-framework based on React hooks API
- Compose React hooks like composing React components
- React hooks tip: event handlers should be the simplest parts of your code. Keep app logic centralized and loosely coupled from the view by sending events with
useReducerinstead of manipulating state withuseState - Making setInterval Declarative with React Hooks
- useFetch: React custom hook for Fetch API with Suspense and Concurrent Mode in Mind
- Playing with React Hooks and Web Workers
- Learn React Hooks by building a game[tutorial]
- useEffect vs useLayoutEffect
- React Hooks: Array Destructuring Fundamentals
- React Hooks: What’s going to happen to my tests?
- React Hooks: What’s going to happen to react context?
- React Hooks: What’s going to happen to render props?
- Why Do React Hooks Rely on Call Order?[hooks]
- React hooks: not magic, just arrays
- How the useEffect Hook Works
- React hooks: changing the mindset
- Making Sense of React Hooks
- React Today and Tomorrow and 90% Cleaner React
- Hooks Docs
- Clean APIs in React with TypeScript #TypeScript
- How to create React components with TypeScript
- Before You memo()
- 4 Ways to Communicate Across Browser Tabs in Realtime
- Is it Safe to Compare JavaScript Strings?
- 10 Awesome JavaScript Libraries You Should Try Out in 2020
- Blogged Answers: A (Mostly) Complete Guide to React Rendering Behavior
- The future of Reach Router and React Router
- Secrets of JavaScript: A tale of React, Performance Optimization and Multi-threading[performance]
- React TypeScript: Basics and Best Practices
- React context vs Redux in 2020
- Understanding JavaScript Pass By Value
- Is JavaScript a pass-by-reference or pass-by-value language?
- Reactive view - the concept
- Understanding Compound Components in React
- 7 Methods for Working With Directories in NodeJS[node]
- Announcing Ionic React
- Use React.memo() wisely
- When to use React Suspense vs React Hooks
- How to use React Context effectively
- Improve React App Performance Through Memoization
- Rocking JS data structures!
- Why Did You Render Mr. Big Pure React Component???
- Track Redundant Re-renders That Caused By React Hooks With “Why Did You Render” Version 3
- Ultimate React Component Patterns with Typescript 2.8[typescript]
- TypeScript HOC (Higher-Order Component) and Decorators in React[typescript]
- [React – Compound components with useContext Hook][tutorial]
- How Does setState Know What to Do?
- My Wishlist for Hot Reloading
- How Does React Tell a Class from a Function?
- Controlling tooltips & pop-up menus using compound components in React[tutorial]
- Why Do We Write super(props)?
- Higher-order components vs Render Props
- How To Master Advanced React Design Patterns:
- Optimizing React: Virtual DOM explained
- Error Boundaries in React 16
- A Secret parts of React New Context API
- Update on Async Rendering
- Beyond React 16: Time Slicing and Suspense API
- How I wrote the world’s fastest React memoization library
- Ultimate React Component Patterns with Typescript 2.8
- Bringing Together React, D3, And Their Ecosystem
- 9 React Tools To Master Your Component Workflow
- Top React and Redux Packages for Faster Development
- Using React Fragments for the first time
- How to greatly improve your React app performance[performance]
- Introduction to react vr[vr]
- Advanced React Router concepts: recursive path, code splitting, animated transitions, and more[router]
- What’s New With Server-Side Rendering in React 16
- Comparison of form libraries in react[form]
- Async operations in React Redux applications
- Writing Clean and Concise React Components by Making Full Use of ES6/7 Features and the Container-Component Pattern
- Using Functions as Children and Render Props in React Components
- A deep dive into children in React
- Functional setState is the future of React
- How to Organize a Large React Application and Make It Scale
- Best UI Frameworks for your new React.js App.
- Simple React Development in 2017
- setState() Gate
- react-bits [patterns][tips][tricks]
- Universal JavaScript Apps with React Router 4 [routing][router]
- Optimizing the Performance of Your React Application
- Optimizing react-redux store for high performance updates [redux]
- Single-Prop HOCs – Better Composition in React
- Next.Js Is it the next big thing in JavaScript?
- Performance Optimizing a React Single Page App: part 1, part 2
- Setting up your React /ES6 Development environment with Webpack, Express and Babel [tutorial][webpack][hot module]
- React.Js: Achieving 20ms server response time with Server Side Rendering and caching [server side render][redis]
- React-Router and Redux: We can do better [redux][router]
- React/Redux Links [redux]
- Testing React Components with Jest
- Building D3 Components with React
- Blitz.js #Next
- Awesome ChatGPT
- Magicast
- usehooks-ts #hooks
- ahooks #hooks
- @react-hookz/web
- useHooks(🐠) #hooks
- awesome-react-hooks
- Absolutely Awesome React Components & Libraries
- Stitcehs #css-in-js
- sorrycc/awesome-javascript
- React Tracked
- alan2207/bulletproof-react
- cassiozen/useStateMachine
- React Query
- Mantine #components #hooks
- Easy Peast #state management
- SWR
- Alpine.js
- dai-shi/react-hooks-async
- Proton Native
- React/Redux Links
- shouldComponentUpdate-Children
- styled-components
- react-primitives
- Ducks
- nwb
- Recompose
- NEXT.js [server side render]
- create-react-app
- Why React Native Is The Right Solution For Enterprise Mobile App Development
- The React and React Native Event System Explained: A Harmonious Coexistence
- React Native Quirks
- Building data-centric apps with a reactive relational database
- Routing using state machines
- Beautiful State Machines #XState
- How to Approach State Management in React, Vue and Angular
- When To Use State Management In Front-end Applications?
- https://twitter.com/ryanflorence/status/1084248892072329216?s=12[xstate][state machine]
- Easy State Management in React Using Unstated
- Practical Redux[redux]
- My take on Redux architecture[redux]
- Redux: Re-Rendering Caused by mapDispatchToProps [redux]
- Dynamic Redux Reducers[redux]
- Replacing redux with the new React context API[react][redux]
- Redesigning Redux[redux][rematch]
- State Management with MobX State Tree
- You are managing state? Think twice.[stent][state machine]
- Getting from Redux to a state machine[stent][state machine]
- Robust React User Interfaces with Finite State Machines[state machine]
- 8 things to learn in React before using Redux[redux][mobx]
- Redux or MobX: An attempt to dissolve the Confusion[redux][mobx]
- The Rise Of The State Machines[state machine]
- A blockchain-backed Redux clone in 105 lines of code
- The Ugly Side Of Redux
- The future of state management - Managing your local data in Apollo Client with apollo-link-state
- Redux First Router First Impressions[router][redux]
- Kea vs setState, Redux, Mobx, Dva, JumpState, Apollo, etc.
- Composing actions with Vuex[vuex]
- redux-data-structures[redux]
- Redux-First Router data-fetching: solving the 80% use case for async Middleware[redux][route]
- A New Redux Action Pattern for TypeScript 2.4+
- Redux Architecture Guidelines
- Five Tips for Working with Redux in Large Applications
- Angular Service Layers
- 3 Things I Learned About Working with Data in Redux [redux]
- How to use Redux on highly scalable javascript applications? [redux]
- Practical Redux [redux]
- Idiomatic Redux: Thoughts on Thunks, Sagas, Abstraction, and Reusability [redux]
- Managing Side Effects In React + Redux Using Sagas [redux][sagas]
- Globalizing Redux Selectors
- Modular Reducers and Selectors
- Taking Advantage of combineReducers
- Why Redux Need Reducers To Be “Pure Functions”
- Epic Middleware in Redux
- Lazy registration with Redux and Sagas [redux-saga][redux]
- Managing State in Angular 2 Applications [angular]
- Redux Step by Step: A Simple and Robust Workflow for Real Life Apps [tutorial][react] [flux]
- Avoiding Accidental Complexity When Structuring Your App State [redux][flux]
- 10 Tips for Better Redux Architecture [redux]
- Recoil[react]
- cerebral/overmind
- Mood
- Meiosis
- Unstated
- Javascript State Machine
- Rematch
- mobx-state-tree
- stent
- machina.js
- xstate
- javascript-state-machine
- store.js
- LogRocket [redux][vuex]
- Alt
- ngrx/store [angular]
- Redux [flux]
- MobX
- Fluxxor [flux]
- Flux
- What’s New In jQuery 3 || 17 Added Features & How To Use Them
- 10 jQuery Performance Tips & Tricks
- Replace jQuery’s Ready() with Plain JavaScript
- Safe Data Fetching in Modern JavaScript
- Streaming requests with the fetch API
- Intercepting JavaScript Fetch API requests and responses
- How to win at CORS #cors
- Replace axios with a simple custom fetch wrapper
- Introducing Gretchen: Making Fetch Happen in TypeScript
- Using Fetch
- Why I won’t be using Fetch API in my apps [axios]
- Rob--W/cors-anywhere
- sindresorhus/ky #post #get #fetch
- Polly.js[stub]
- Creating a Book Cover Using JavaScript and p5.js
- Image Processing in Javascript
- A 'modern 3D API' wrapper for WebGL
- Getting Started With Paper.js: Animation and Images
- Getting Started With Paper.js: User Interaction
- Getting Started With Paper.js: Paths and Geometry
- Getting Started With Paper.js: Projects and Items
- Comparing JavaScript animation libraries
- How to Use the Animation Inspector in Chrome DevTools
- Your WebGL aiders
- Toggling Animations On and Off[tutorial]
- 10 principles for smooth web animations
- An Introduction to mo.js
- Animating the DOM with Anime.js
- Bringing to life with Web Animations API
- Loki #visual regression
- Your Jest tests might be wrong
- Complete guide on Playwright visual regression testing
- JavaScript testing #1. Explaining types of tests. Basics of unit testing with Jest
- How Cypress Freezes CSS Animations And You Can Too
- Node.js Integration Test Best Practices
- Testing in production: using JSON Schema for 3rd party API response validation
- Dynamic API Tests Using Cypress-Each Plugin
- 7 Ways To Test Your Website On Safari Browser from Windows Device #BrowserStack #LamdaTest #Browserling #CrossBrowserTesting #Sauce Labs
- Puppeteer, Selenium, Playwright, Cypress – how to choose?
- Cypress vs Selenium vs Playwright vs Puppeteer speed comparison
- Loki: A Visual Regression Testing for Your Storybook Projects
- Interaction Testing sneak peek #storybook
- Test Feature Flags Using Cypress and Flagsmith
- Cypress Live-Reload Tests on Code Changes
- Cypress request and cookies
- Load Fixtures from Cypress Custom Commands
- Introducing the Cypress Component Test Runner– new in 7.0.0
- Stop mocking fetch #msw #faker.js
- 7 Ways to Debug Jest Tests in Terminal
- Effective React Tests
- Testing Implementation Details
- Code Coverage for Vue Applications[vue][coverage]
- End-to-End Snapshot Testing[cypress][snapshot]
- Write Your First Vue Component Test[cypress][vue]
- Running Cypress tests in a monorepo[cypress][monorepo]
- Core Cypress Lessons We Learned That 10x-ed Our E2E Automation
- Fast and reliable cross-browser testing with Playwright
- Monitor Visual Changes in Websites with Puppeteer and Resemble JS
- Testing a Virtual List component with Cypress and Storybook
- Behavior Driven Development (BDD) and Functional Testing[BDD][tdd]
- Generated tests with XState and Cypress
- Setting up Cypress with axe for accessibility
- Write fewer, longer tests
- Await, do not make your E2E tests sleep[e2e][cypress]
- Rethinking Software Testing: Perspectives from the world of Hardware
- Code Coverage for End-to-end Tests
- 4 things that I always manually test
- Testing Implementation Details
- A personal review of automated testing tools in the JavaScript world
- Everything That's Not Tested Will Break
- An Overview of JavaScript Testing in 2018
- Automatic visual diffing with Puppeteer[puppeteer]
- Stubbing HTTP Requests With Sinon[sinon]
- Test your DOM with Data Attributes
- End-to-end Tests that Don’t Suck with Puppeteer
- Chromeless Playground: Chrome Automation Made Simple
- Snapshot testing the hard way
- Automated testing with Headless Chrome
- The Outrageous Cost of Skipping TDD & Code Reviews
- Testing Service Workers
- Getting Started with Headless Chrome [headless]
- An Overview of JavaScript Testing in 2017
- [Headless Chrome](Headless Chromium) [chrome][headless]
- Testing Your Frontend Code
- TDD the RITE Way [tdd]
- Testing React components with Jest and Enzyme
- DOM Testing React Applications with Jest [react]
- Unit testing front-end JavaScript with AVA and jsdom
- Worthwhile Testing: What to test in a React app (and why) [react]
- An Intro to Monkey Testing with Gremlins.js
- Getting Started with Create React App and AVA [react][nvm][macos][homebrew]
- Page object for testing React.js components [react][component]
- 5 Common Misconceptions About TDD & Unit Tests
- 5 step method to make test-driven development and unit testing easy [tdd]
- What is property based testing (and how to do it in JavaScript)?
- playwright-fluent
- Mock Service Worker (msw)
- faker.js
- Mocks Server
- Playwright
- QA Wolf
- Stryker [mutation testing][mutant]
- Axe
- Baretest
- Puppetry
- Newman
- Puppeteer
- Intern
- Puppeteer[chrome headless]
- Chromeless Playground
- snap-shot
- TestCafe
- AVA [test runner]
- Karma [test runner]
- WebdriverIO
- Monorepo Maestros
- 5 JavaScript Build Systems for 2024
- Blogged Answers: My Experience Modernizing Packages to ESM
- Best practices for creating a modern npm package
- Introducing the new npm Dependency Selector Syntax
- Monorepos in JavaScript & TypeScript
- Sponsoring dependencies: The next step in open source sustainability
- Monorepos in JavaScript & TypeScript
- Lerna has gone. Which Monorepo is right for a Node.js BACKEND now? #Nx #Turborepo
- 5 Best Practices to Choosing Third-Party NPM Packages
- Simple monorepos via npm workspaces and TypeScript project references
- TypeScript and native ESM on Node.js #package.json #typescript
- What is monorepo? (and should you use it?)
- How to deploy only changed packages in a Lerna Monorepo
- Is Monorepo for You? — 2020[monorepo]
- How to find unused npm packages?[depcheck][npm]
- How to successfully manage a large scale JavaScript monorepo aka megarepo
- Why Lerna and Yarn Workspaces is a Perfect Match for Building Mono-Repos – A Close Look at Features and Performance[lerna][npm][yarn][yarn workspaces]
- npm Commands and Features You Should Know
- Running Multiple Versions of Node.js with Node Version Manager[nvm]
- Size Limit: Make the Web lighter
- Scan your projects for crossenv and other malicious npm packages[security]
- Introducing npx: an npm package runner
- Why should we use pnpm?
- Offline installation of npm packages [npm]
- https://medium.com/@jacob.h.page/common-npm-mistakes-51bf8989079f#.9nhzzq697
- Yarn
- npms.io
- Node/NPM
- JSPM
- Bower
- dependency-cruiser
- publint
- npm-check
- qnm
- Turborepo #monorepo
- pnpm
- Volta
- Verdaccio
- Awesome npm scripts
- depcheck
- bolt
- Lerna
- Size Limit
- Yarn
- npm_lazy
- local-npm
- Node Version Manager (NVM)
- Kuto, a reverse JS bundler
- An in-depth perspective on webpack's bundling process #webpack
- You may not need a bundler for your NPM library
- How to use webpack and HTML Webpack Plugin to generate HTML pages for multiple entries in 2 steps?
- Why and how to transpile dependencies of your JavaScript application
- When should you leverage Module Federation, and how?
- Announcing Parcel CSS: A new CSS parser, compiler, and minifier written in Rust!
- webpack or esbuild: Why not both?
- Comparing the New Generation of Build Tools
- SurviveJS Webpack: Build Analysis #webpack
- IE11 and the Missing Polyfills
- An in-depth guide to performance optimization with webpack
- Webpack 5 Module Federation — Stitching two simple bundles together
- Webpack 5 Module Federation: A game-changer in JavaScript architecture
- Fast JavaScript bundling with esbuild
- Rome, a new JavaScript Toolchain
- Webpack: Reusing Module in Multiple Entries[webpack]
- Enable source-map on production?
- Should We All Start Implementing Differential Serving?[modern build]
- How to delete ALL node_modules folders on your machine and free up HD space!
- Build Performance[webpack]
- A better strategy for long term caching[webpack]
- What's what? - Package.json cheatsheet!
- Differential Serving [modern][es5]
- Introducing: @pika/pack
- Code-splitting for libraries—bundling for npm with Rollup 1.0
- Remove unused CSS with PurgeCSS
- Decrease Front-end Size[webpack]
- Tomorrow’s ES Modules Today![esm]
- Webpack 4 Tutorial: from 0 Conf to Production Mode[webpack]
- The Lost Art of the Makefile
- Announcing SMP: Speeding Up webpack With Timers[webpack]
- Confused about the different types of dependencies in NPM or Yarn?
- Native ES Modules in NodeJS: Status And Future Directions, Part I[mjs][cjs]
- Everything You Need To Know About Parcel: The Blazing Fast Web App Bundler[parcel]
- How to Improve the Frontend Dev Experience without a Bundler[unchained]
- A study about how to improve frontend dev experience without a bundler[unchained]
- State of Modules in JavaScript[esm]
- Critical CSS and Webpack: Automatically Minimize Render-Blocking CSS
- Deploying ES2015+ Code in Production Today
- Delivering untranspiled source code via npm
- Predictable long term caching with Webpack
- OPTIMIZING WEBPACK FOR FASTER REACT BUILDS [webpack][dll]
- Building Vendor and Feature Bundles with webpack [webpack][dll]
- Webpack Plugins we been keepin on the DLL [webpack][dll]
- Optimizing Webpack build times and improving caching with DLL bundles [webpack][dll]
- One build tool to rule them all—Blendid!
- Prepack.io
- MAY 02 Webpack: A simple loader [webpack]
- How to do proper tree-shaking in Webpack 2 [webpack][tree shaking]
- Tree-shaking versus dead code elimination
- ES6 modules support lands in browsers: is it time to rethink bundling?
- webpack bits: Getting the most out of the CommonsChunkPlugin()
- Setting up multi-platform npm packages [main][module][es2015]
- Cut the File Size with These Three HTML Minification Tools
- Travis - a free CI for an opensource project [ci][travis]
- The Fine Art of the Webpack 2 Config [webpack]
- Modern JavaScript Apps with Neutrino [webpack]
- Optimising your application bundle size with webpack
- A Guide to Managing Webpack Dependencies [webpack]
- Getting Started with Webpack 2
- History and Background of JavaScript Module Loaders
- vite-plugin-federation
- bundlejs
- BundlePhobia
- PackagePhobia
- Optimize Plugin for Webpack
- WebpackRemoteTypesPlugin #webpack #module fedaration
- SWC
- esbuild-loader
- Webpack Bundle Analyzer #webpack
- whybundled #webpack
- Statoscope #webpack
- Estrella
- Vite
- Vitesse
- Microbundle
- esbuild
- Community plugins for esbuild
- Pika
- Skypack
- Snowpack
- pikapkg/pack
- devolution
- Rome
- webpack-libs-optimizations
- prepack
- Polyfill.io
- Parcel
- Brunch
- webpack-common-shake
- autodll-webpack-plugin
- Getlibs
- Fusebox
- Source Map Explorer
- Butternut
- Blendid
- fly [generator]
- Gulp [stream]
- webpack-bundle-analyzer
- System.js
- Webpack
- Browserify
- Require.js
- es-module-loader