The Inevitable Evolution of React Hooks

Description

This image is a screenshot of a tweet from the user Ansub (@justansub). The tweet's text reads, 'React 20 be like:'. Below this caption is a stylized image of a code editor with a dark theme. The code snippet contains two lines: the first is a string literal, '"use using"', which likely represents a new directive similar to '"use strict"' or '"use client"'. The second line is a nonsensical piece of code: 'using use = useUsing('use')'. This syntax is a satirical exaggeration of the React framework's hook-based architecture, where functions are prefixed with the word 'use' (e.g., useState, useEffect). The meme humorously projects this convention into the future, suggesting that 'React 20' will have a convoluted, meta, and almost tautological syntax. It's a commentary on framework complexity and the potential for naming conventions to become absurd when taken to their logical extreme, a joke that deeply resonates with frontend developers who have followed React's evolution

Common Tags

React Frontend DeveloperHumor FrameworkChurn RelatableDevExperience TechHumor ModernTechStack API ApplicationProgrammingInterface

Comments

Anonymous ★ Top Pick This isn't a joke, it's the inevitable outcome of the RFC process for adding explicit resource management to React, where the naming convention was the only thing everyone could agree on

Anonymous ★ Top Pick

This isn't a joke, it's the inevitable outcome of the RFC process for adding explicit resource management to React, where the naming convention was the only thing everyone could agree on
Anonymous

At this rate, React 20’s RFC will propose `useUse` - and the linter will yell if you forget to `useUsing(use)` before brunch
Anonymous

At this rate, React 30 will just be a Lisp dialect where every function is a variation of 'use' and we'll need a PhD in category theory just to understand why useState doesn't actually manage state anymore
Anonymous

When React's hook naming convention becomes so meta that you need a hook to use hooks, you've achieved peak framework abstraction. This is what happens when 'convention over configuration' meets infinite recursion - eventually you'll need useUseUsingUseEffect() just to update a counter. The real question is: will React 20's compiler optimize this into a single 'u' or will we finally admit that maybe, just maybe, we've taken the 'use' prefix a bit too seriously?
Anonymous

In React 20, a “using use = useUsing('use')” block disposes your hook-of-hooks; ESLint’s new Rules of Using will finally explain those 17 unexpected re-renders
Anonymous

React 20's use(): finally breaking 'top-level only' hooks - with turtles all the way down
Anonymous

At this rate React 20 won’t need imports - just prepend “use” and hope the Rules of Hooks can negotiate ownership with TypeScript’s “using” before hydration
@FirokOtaku 1y

Future Java be like: class FactoryFactory extends AbstractFactoryFactory<FactoryFactory> implements IFactory { final FactoryFactoryMeta meta; /** * @version 0.2.0 * @apiNote 0.2.0 fixed typo issue */ protected FactoryFactory(FactoryFactoryMeta meta) { this.meta = meta; } @Override Factory buildFactory() { return new Factory(meta); } }
1. @trainzman 1y
  
  Future C#:
  
  @azizhakberdiev 1y
  
  use of new keyword is deprecated Use malloc, calloc and realloc instead /s
2. @trainzman 1y
  
  More like Future Java be like
  
  @seekonelinesky 1y
  
  Spring: do not expect for the future, I am doing this right now
  
  @TheFloofyFloof 1y
  
  @Bean
3. @Diotost 1y
  
  It won't work. There is a typo. Facotry instead of Factory
@Diotost 1y

Was a typo.
1. @FirokOtaku 1y
  
  fixed.