I want to share a list of 100 newsletters that I’ve made over the last 2.5 years for frontend developers in my last company.
The main goal of this newsletter was to spread knowledge within frontend community, increase developer productivity and show good patterns and practices in our technology stack (TypeScript, React, GraphQL).
Other topics like soft skills, career development and other random but interesting things related to programming were also included from time to time.
Newsletters were composed from the following sources
Youtube channels
Blogs and newsletters
- React Status
- This Week In React
- ECMAScript news
- Bytes
- GraphQL Weekly
- Awesome Node.js Weekly
- cssweekly
- The Pragmatic Engineer
- ByteByteGo Newsletter
- The Platform Space
- Fish Food for Thought
- vscode.email
Newsletter list
Weeks 1 - 10
Week 1
- TypeScript Template Literal Types
- Is WebAssembly magic performance pixie dust?
- Experimental laboratory of user interface patterns and interactions
- Headless UI
- Styled Components guide
Week 2
- TypeScript generic forward refs
- How to type a React from onSubmit handler
- Next generation frontend tooling with ViteJS - Open Source Friday
- Functional React With Styled Components
- Feature driven software design architecture
Week 3
- TypeScript function syntaxes
- Why React needs a key prop
- Don’t Use the Sidebar in VS Code!
- TypeScript React cheatsheet
- Philosophy of software design
Week 4
- Building (And Re-Building) the Airbnb Design System
- Broken Promises - James Snell, NearForm
- 4Developers 2018: RxJS: Everything is a stream
Week 5
Week 6
Week 7
- CSS tip
- Async Await try-catch hell
- Why you cannot condition React hooks
- The plan for React 18
- Target blank
- Practical React Query
Week 8
- CSS Inherit, initial, unset, revert
- Snipsnap Templates
- Emulating component behavior with JavaScript closures
- What You NEED To Know About React 18
Week 9
- A visual guide to Node.js streams
- Merge objects & other types recursively
- Check your npm module for unused dependencies
- Things that still don’t quite work at Spotify… and how we’re trying to solve it
- Demystifying Styled Components
- Not All Components Are Created Equal
- SolidJS
- Designing a dataflow editor with TypeScript and React
- Open-source Software Engineering and Leadership principles
Week 10
Weeks 11 - 20
Week 11
- JavaScript’s Temporal API: The Best WayTo Manage Date And Time
- TypeScript conditional props
- Readme editor
- Design System Podcast
Week 12
- Conducting tech interviews - HTTP 203
- Code Review: Google’s zx (write better shell scripts)
- How to encode and decode strings with base64 in JavaScript
- How to learn stuff quickly
- React render always rerenders
Week 13
- New hithub feature
- Next.js 11.1
- Tagged template literals - the magic behind Styled Components
- How one conditional can entangle your React app
- React Children iteration methods
Week 14
- Today’s 28 Best React Blogs
- Live with Kent: Writing an ESLint plugin
- Semantic HTML markup
- React mediator component
Week 15
- Concurrent React from scratch
- Using GIT for version control
- Fix useEffect re-running on every render
- Advanced TypeScript cheatsheet
- Records and tuples for React
- Styleguides, component libraries, design systems
- Setting-up ZSH with autosuggestions
Week 16
- AI-powered app that removes background noise and echo from meetings
- A tool for writing better scripts
- React polymorphic components with TypeScript
- ARIA spec for the uninitiated
- Button label alignment
- New TypeScript docs
- I am and average Employee
Week 17
- 13 Advanced (but useful) Git Techniques and Shortcuts
- Bret Victor The Future of Programming
- Dynamo: Amazon’s Highly Available Key-value Store
- OWASP top 10
- Incomplete List of Mistakes in the Design of CSS
- How to stop languishing and start finding flow
Week 18
- Web Vitals patterns
- How to “Google It” like a Senior Software Engineer
- React and the Meta of the Web
- Learn something new with GraphQL
- Why do webdevs keep trying to kill REST
- JavaScript developer guide to browser cookies
- React types for children are broken
Week 19
- Lessons learned from running GraphQL at scale
- Project management at big tech
- Designing CSS shadows
- Reducing the need for pseudo elements
- Minding the gap
- React readability analysis of implementing custom hooks
- Understanding min/max/fit content
- React inline edit
- Why flow matters more than passion
- Reinventing Organizations
- Fighting JavaScript tests complexity with the basic principles
Week 20
Weeks 21 - 30
Week 21
- GraphQL directives you should know about
- GraphQL examples
- GraphQL nulls cheatsheet
- Content Security Policy
- Inversion of Control
- Following people online is dangerous
- A keyboard accessibility horror game
- A note on function components default parameters
- Next.js conf
Week 22
- HTML with superpowers
- UI performance
- Collection of thinking tools and frameworks to help you solve problems
- Code search engine
- React render cheatsheet
- Introduction to Test Driven Development with React
- Great alt text
- Photoshop on the web
- Project management app
- Object fit/background size in CSS
Week 23
- Thinking in React
- Tracing SRE’s journey in Zalando - Part I
- Decision making in software engineering teams
Week 24
- A crash course in just in time jit compilers
- js13kGames winners
- 4 tips for better asynchronous code
- Building an effective Image Component
- The Difference Between in and hasOwnProperty in JavaScript
- structuredClone API
- Why we ditched scrum in favor of kanban and incorporated a classid SDLC process
- Array
at
method
Week 25
- The case for developer experience
- Deep dive into Node.js architecture
- sudo rm -rf / === npm install
- How the TypeScript Compiler Compiles - understanding the compiler internal
- Mastering TypeScript template literal types
- Chrome Dev Summit 2021 recap
- Developer tools secrets that shouldn’t be secrets
Week 26
- Node.js event loop in action
- Why Discord is switching from GO to Rust
- Rust tooling in JavaScript
- Invisible backdoor
- Influencing without management authority as a senior individual contributor
- How arrays work
- The developers guide to Core Web Vitals
- Tech blogs from Devops website
- GO like error handling in TypeScript
Week 27
- TypeScript tip
- GraphQL performance explained
- React render refs
- TypeScript function overloading
- Const enums in TypeScript
- Guide to modern CSS colors
- Discriminated unions in TypeScript
- How JavaScript engines achieve great performance
- Advent of JavaScript
- Advent of Code
Week 28
- John Carmack on inlined code
- 2022 is gonna be wild for developers…
- HTTP Archive Almanac
- Unintentional layout effect
- Abstract Syntax Trees
- Coding Interview with Dan Abramov
- Is JavaScript Spread a Performance Killer?
- Fake coding interview with Dan Abramov
- Defensive CSS
- React Conf
Week 29
- Clean Architecture with Alex Bespoyasov
- Cypress basics - variables
- Improving github code search
- TypeScript control flow analysis
- TypeScript function overload
- The React State Museum
- TS Belt functional library
Week 30
- RubyConf 2015 - Hacking Spacetime for a Successful Career by Brandon Hays
- Ten I-Statements About Refactoring
- a11y myths - common myths about accessibility
- Type | Treat – Wrap-up - TypeScript challenge
- Yelp GraphQL Schema Design Guidelines
- A hundred things I learned working on the react team - Dan Abramov
- State of React | December 2021
- Learnings from React Conf 2021
Weeks 31 - 40
Week 31
-
Fig adds VSCode-style autocomplete to your existing terminal
-
Use CSS.escape for escaping “strange” ids, classes and what are not
-
Terminal Tip:
Git can be pretty daunting especially in a conflict state. Let’s say you find yourself in this situation and want to accept all the alterations made by the other person, you can accept all of their changes by doing the following:
git checkout --theirs . git add .
You can do the same in reverse:
git checkout --ours . git add .
Keep in mind that this is pretty drastic, so make sure you really want to wipe everything out before doing it.
Week 32
- What NPM Should Do Today To Stop A New Colors Attack Tomorrow
- Writing Better CSS
- 30 Frontend Tips
- FREE E-BOOK Understanding JavaScript Promises
- KNOW YOUR “ONE JOB” AND DO IT FIRST #controversial
- know how your org works (or how to become a more effective engineer)
- Cheat sheet: strings
- Cheat sheet: Arrays
Week 33
- Dan Abramov SLAYS Frontend Interview w/ Ex-Twitch Engineer
- Frontend Developer Resources 2022
- Let’s settle this - quick & fun survey
- How not to learn TypeScript
- New in Node.js: node: protocol imports
- The Most Important Thing I Learned About Writing Readable Code
- Fast and simple Node.js version manager, built in Rust
- GraphQL Galaxy 2021
Week 34
- A definitive guide to conditional logic in JavaScript
- Tao of React - Software Design, Architecture & Best Practices
- Hook traps: UseEffect and Stale Closures
- Imperative vs Declarative Programming
- Javascript Rewind 2021 – Top 15 JS article of the year
- What’s new in the latest GraphQL spec
- Flexbox layout trick
- HTML tip to block translations
- The package-lock.json file
Week 35
- The CSS :has() selector is way more than a “Parent Selector”
- Holiday Book Recommendations for Engineering Managers, Software Engineers and Product Managers
- What I learned from reading the GraphQL Spec
- React Elements vs React Components
- Accessible heading structure
- TypeScript Cheat Sheets
- Building a theme switch component
- Building UI Components With SVG and CSS
Week 36
- Smooth CSS shadow generator
- Div divisiveness
- Tree Lists With Indeterminate Checkboxes in React
- Becoming a Better Writer
- Mastering React Batch Updating
- Publishing and consuming ECMAScript modules via packages – the big picture
- A pipe operator for JavaScript: introduction and use cases
- The Story of React
Week 37
- How to keep up with web development without falling into despair
- What’s New In DevTools?
- The Anatomy of a GraphQL Request
- An Introduction To Type Programming In TypeScript
- How does !important actually work? (It’s not what you think!)
- Mastering React Memo
- Dynamic Static Typing In TypeScript
- ECMAScript Internationalization API
Week 38
- 10 bad TypeScript habits to break this year
- How not to learn GraphQL
- Eric Elliott’s “Composing Software” Series
- Debugging JavaScript
- The State of JS 2021
- Oh Shit, Git!?!
- CHECK YOUR WCAG COMPLIANCE
- The 10 commandments of navigating code reviews
Week 39
- How many re-renders is too many?
- A new year, a new MDN
- The inset CSS property
- The Story of Asynchronous JavaScript
- 10 React Antipatterns to Avoid - Code This, Not That!
- My white whale: A use case for will-change
- It’s a Jungle Out There: What’s Really Going on Inside Your node_modules Folder
- Fairy Tales, and the Implications of Immutability
Week 40
- An open-source kit to optimize your developer workflow
- A Deep Dive Comparison Between useMemo And useCallback
- Assertion Functions in TypeScript
- Explore community driven list of top resources in React
- A Complete Guide To TypeScript’s Never Type
- How do primitive values get their properties?
- The Story of React
- Why Did And Don’t You Need To Import React
Weeks 41 - 50
Week 41
- The display of types
- What’s Really Going On Inside Your node_modules Folder?
- Content design: planning, writing and managing content
- Leave the code better than you found it
- How Containment in React Can Improve Your Code
- Pattern Matching in JavaScript
- optional vs. undefined
- Death by a thousand useCallbacks
Week 42
- Use React.VFC for components that shouldn’t have children
- Implementing advanced usePrevious hook with React useRef
- Announcing CodeSandbox Projects
- Preemptive Memoization In React Is Probably Not Evil (Yet)
- Hooks Considered Harmful
- Claymorphism: Will It Stick Around?
- A React app to interactively visualize JavaScript’s Event Loop
- React 18 is now available on npm!
Week 43
- Best practices for writing code comments
- The Story of Next.js
- 100 cool web moments by Chrome team
- How Does Shallow Comparison Work In React?
- Handling URLs in JS
- TypeScript - How some utility types are implemented
- How to Write TypeScript Like a Haskeller
- When Does React Render Your Component?
Week 44
- The Ultimate TypeScript Thread - tips from twitter
- How return await can slow down your code
- Collection of TypeScript type challenges with online judge
- Multiline Text Truncation With CSS line-clamp
- How to match HTML elements with an indeterminate state
- HTML semantics
- Those HTML Attributes You Never Use
- My guiding principles after 20 years of programming
Week 45
- The Front-End Developer’s Guide to the Terminal
- WARP IS A BLAZINGLY FAST, RUST-BASED TERMINAL REIMAGINED FROM THE GROUND UP TO WORK LIKE A MODERN APP
- quicktype produces nice types and JSON (de)serializers for many programming languages.
- Accessible React Forms
- CSS Parent Selector
- An Overlooked Factor For Performance Optimization In React
- React components composition: how to get it right
- Understanding Layout Algorithms
Week 46
- TypeScript: How the compiler compiles
- Flexibly Centering an Element with Side-Aligned Content
- TypeScript tips and Tricks with Matt
- The videos from the Devs for Ukraine conference
- The Patterns of Scalable, Reliable, and Performant Large-Scale Systems
- You should be reading academic computer science papers
- Agile and the Long Crisis of Software
- Hooks, Dependencies and Stale Closures
Week 47
- Understanding “keyof typeof”
- Flexible Design System Components With “as/is” Props
- Filtering arrays with TypeScript type guards
- Deep-copying in JavaScript using structuredClone
- Code Reviews 101 - The Basics
- Practical Use Cases for :has() Pseudo-Class
- Deep Dive into Text Wrapping and Word Breaking
- 8 common React error messages and how to address them
Week 48
- The Story of Concurrent React
- Four Eras of JavaScript Frameworks
- A Practical Guide to Aspect Ratio in CSS
- Learnings about the future of the web from Reactathon
- TypeScript protip: accept any string, but suggest some specific values on autocomplete
- Underrated vscode feature: “Show Call Hierarchy”
- Web component JS frameworks overview by their syntax and features
- The Story of Web Components
Week 49
- Magical SVG Techniques
- React key attribute: best practices for performant lists
- The Surprising Truth About Pixels and Accessibility
- How To Type React useCallback Using TypeScript
- Bringing page transitions to the web
- Little story about “ajax”, aka
XMLHttpRequest
, akafetch
- How JavaScript works: A deep dive into esbuild
- A curated list of delightful Visual Studio Code packages and resources.
Week 50
- Lesser-Known And Underused CSS Features In 2022
- Stop find-and-replacing in VSCode
- Undo Last Commit in VSCode
- History of the web - timeline
- #FAIL • Kevlin Henney • GOTO 2021
- Web Apps, Web Sites, Are they all the Same?
- Approaches for shipping code to production reliably, every time.
- useEvent, the missing React hook
Weeks 51 - 60
Week 51
- State of CSS 2022
- logpoints in Chrome
- Reactathon 2022 videos
- 7 TypeScript Utility Types For React Developers
- GraphQL API Schemas: Designing a better one
- Nate Moore: WebAssembly in the JavaScript Ecosystem
Week 52
- React project structure for scale: decomposition, layers and hierarchy
- A Complete Guide To Accessible Front-End Components
- Reading Source Code: React-Query
- Goodbye, useEffect: David Khourshid
- How to useMemo and useCallback: you can remove most of them
- How We Reduced Bugs in Our React Codebase
Week 53
- Software Engineering - The Soft Parts
- CSS DAY — day 1
- JSConf Budapest 2022
- React Labs: What We’ve Been Working On – June 2022
- Ecma International approves ECMAScript 2022: What’s new?
- JS functions fundamentals
- My Bleeding Edge Tech Stack for 2025
Week 54
- Ensuring Excellence
- In defense of blocks for local scopes
- Capture Phase Event Handling in React
- Practical CSS and design tips that helps in building future-proof user interfaces.
- My Wonderful HTML Email Workflow
- Highlights of OpenJS World 2022 - What’s next in the OS ecosystem
- OpenJS World 2022 playlist
- Stack Overflow Developer Survey 2022
Week 55
- When You Should Prefer Map Over Object In JavaScript
- Notes on maintaining an internal React component library
- Better scrolling through modern CSS
- You Might Not Need an Effect
- The React core team finally have opinions about CSS
- 3 useful CSS hacks
- New to the web platform in June
- CSS Day 2022 conference playlist
Week 56
- React Enterprise Component Patterns - Inversion of Control and JSX Injection via Context API
- SPAs: theory versus practice
contenteditable
trick- Quick Refactoring technique
- Are you sure that’s a number input?
- The mystery of React Element, children, parents and re-renders
- The new wave of React state management
Week 57
- How Senior Programmers ACTUALLY Write Code
- 7 Lessons From The Software Craftsman
- Web Browser Engineering
- Actionless and Stateless Reducers in React
- Applying SOLID principles in React
- Reading Source Code: React
Week 58
- Style with Stateful, Semantic Selectors
- Technical Writing for Developers
- In Praise of Stacked PRs
- How to Slack
- Our first look at INFER
- 500ms to 1.7ms In React: A Journey And A Checklist
- David Khourshid @ ReactNext 22 - Goodbye, useEffect
- Examples of large production-grade, open-source React apps
Week 59
- John Carmack: Doom, Quake, VR, AGI, Programming, Video Games, and Rockets
- Why React Re-Renders
- Avoiding useEffect with callback refs
- Objects, Functions, and Type Narrowing
- How TypeScript Conditional Types Work
- Unleash the power of Fragments with GraphQL Codegen
Week 60
Weeks 61 - 70
Week 61
- Why you should never feel guilty about “wasting time”
- The Best Solution to Burnout We’ve Ever Heard
- Understanding Garbage Collection in JavaScriptCore From Scratch
- Beautify Github Profile
- Awesome React Components & Libraries
- Understanding useMemo and useCallback
Week 62
- Learn to write better, resilient CSS
- How to use Forms in React
- An interactive guide to color & contrast
- How to speed up your workflow with Console shortcuts | DevTools Tips
- Why Every React Developer Should Learn Function Composition
- CSS container queries are finally here
- TypeScript: enums vs. string literals
- The story of Amazon Web Services
Week 63
- Exploring the Underrated Output Element
- React Error Boundaries: A Complete Guide
- GhostWriter Beta and AI Mode
- Primitive vs Reference Values in JavaScript
- Building an aircraft radar system in JavaScript
- Dependency Injection in JS/TS – Part 1
- An overview of Node.js: architecture, APIs, event loop, concurrency
- New to the web platform in August
Week 64
- Advanced React component composition
- Frontend security primer
- With or without enums in TypeScript
- Get smarter every day
- React forms tip
- Using React as a framework
- Building Complex Types in TypeScript
Week 65
- Interactive tutorial on using generics in TypeScript
- Advanced TypeScript: Let’s Learn Generics!
- Qwik… the world’s first O(1) JavaScript framework?
- How QR codes work
- The new wave of Javascript web frameworks
- Introducing Ezno
- I made Minecraft in Minecraft with redstone!
- Interactive exercises to get familiar with TypeScript’s most advanced features
Week 66
- JavaScript simulation of driving at night time on the motorway
- CSS almanac - what’s actually used
- A little semantic HTML trick for React components
- Is coding really dead? 6 trends that look bad
- Why We’re Breaking Up with CSS-in-JS
- UseState: Asynchronous or what?
- The Web’s Next Transition
- Top VS Code Tips, Tricks & Extensions to supercharge your workflow
Week 67
- Prioritise content over components
- Collection of components based on examples from the world of design systems
- Design Principles For The Web - Jeremy Keith
- VS Code Timeline Restores Lost Work That Git Can’t
- From React to htmx on a real-world SaaS product: we did it, and it’s awesome!
- Optimizing resource loading with Priority Hints
- The HTTP crash course nobody asked for
- Typed JavaScript? For real? The “type annotations” proposal and what it’s all about - Gil Tayar
Week 68
- Keynote: Why web tech is like this - Steve Sanderson
- Nordic.js 2022 conference playlist
- Next.js 13… this changes everything
- Let’s talk about web components
- The State of Frontend in 2022
- Why would anyone need JavaScript generator functions?
- npm bin script confusion: Abusing ‘bin’ to hijack ‘node’ command
Week 69
- The State of GraphQL in 2022
- ViteConf 2022 | Full day | 42 talks about the tools and frameworks innovating in the Vite Ecosystem
- CSS features that might one day make their way to the browser
- What’s New In DevTools: Halloween Edition
- Assembly interpreter inside of TypeScript’s type system
- Timeline of a React Component With Hooks
- Everything new from GitHub Universe 2022
Week 70
- React Advanced London 2022
- Amazing New VS Code Extension: Console Ninja
- Writing for Engineers
- Inside the mind of a frontend developer: Hero section
- What’s so great about functional programming anyway?
- The evolution of scalable CSS
- Fetching data in React: the case of lost Promises
- An Interactive Guide to Flexbox
Weeks 71 - 80
Week 71
- Jenn Creighton - The How and Why of Flexible React Components - ReactJS Girls Conference
- React Brussels 2022 playlist
- John Carmack: Best programming setup and IDE
- Data Structures In Frontend JavaScript In The Real World
- Color Formats in CSS
- CSS History Timeline
- On Migrating from Cypress to Playwright
- Top Announcements of AWS re:Invent 2022
Week 72
- Improving React Interaction Times by 4x
- The Hunt for Prod Bugtober: Apollo GraphQL Edition
- RIP React Router?
- TypeScript 4.9 has landed
- 5 Terrific Git Commit Tips
- Myths about useEffect
- The State of CSS 2022
- Frontend Engineer Archetypes
Week 73
- Web workers are not the answer
- React Dev, You Need To Know @container!
- What is a realm in JavaScript?
- ASTs, ESLint, and TypeScript ESLint with Josh Goldberg, Open Source Developer
- What Is Single Sign-on (SSO)? How It Works
- Things are gonna get weird in 2023
- Here’s a fun React tip:
useReducer
is a betteruseState
, and it’s easier to adopt than you may think. - Lessons learned: how I’d rebuild a social web app like Twitter today
Week 74
- A collection of 70 hand-picked, web-based tools which are actually useful
- Accessible Front-End Patterns For Responsive Tables
- Infer is easier than you think
- SvelteKit is my mistress
- A Software Developer’s Guide to Writing
- Why You Should Use String Literal Unions Over Enums in TypeScript
- Avoid These Common Pitfalls Of React useState
Week 75
- Getting Stuff Done: a Guide to Productive Software Engineering
- This is the Only Right Way to Write React clean-code - SOLID
- The GPT-3 Architecture, on a Napkin
- Reflections on a career managing React with Tom Occhino
- Function Overloading in TypeScript
- React ref Callback Use-Cases
Week 76
- Github Copilot Internals
- The Ultimate Form Abstraction
- Hello React, Goodbye useEffect (I Hope)
- Handling errors like a pro in TypeScript
- The gotcha of unhandled promise rejections
- The State of JS 2022 results
- A Cure for useState Hell
Week 77
- The Official JavaScript Tier List is Here
- 2022 JavaScript Rising Stars
- Everything you need to know about Concurrent React (with a little bit of Suspense)
- React JS Best Practices From The New Docs
- 10 Tips for Mastering TypeScript Generics
- The Key To Good Component Design Is Selfishness
- The Art Of Code Review: From Hatred To Acceptance
Week 78
- CLI tools you won’t be able to live without
- How to debounce and throttle in React without losing your mind
- Structure of a TypeScript Error
- Things I want to see in JavaScript and Frontend development in 2023
- 10 Web Development Trends in 2023
- Taking Back “Software Engineering” – Craftsmanship is Insufficient • Dave Farley • GOTO 2022
Week 79
- React.js: The Documentary
- Making sense of TypeScript using set theory
- How to communicate effectively as a developer
- Don’t use return types, unless…
- All the best things about Visual Studio Code that nobody ever bothered to tell you
- React’s Third Era
- Speeding up the JavaScript ecosystem - eslint
Week 80
- React recursively re-renders child components, but there is a nuance
- Demystifying UI Frameworks and Theming for React Apps
- Understanding monomorphism can improve your JavaScript performance
- The Guide To Responsive Design In 2023 and Beyond
- Custom React Hooks and When to Use Them
- The technology behind GitHub’s new code search
- Why Sorting Is Harder Than It Seems
Weeks 81 - 90
Week 81
- The Missing Semester of Your CS Education
- DevTools Tips
- The complete guide to safe type narrowing in TypeScript
- How to handle errors in React: full guide
- Modularizing React Applications with Established UI Patterns
- CoPilot Review: My Thoughts After 6 Months
- Rewriting TypeScript in Rust?
Week 82
- The Evolution of Signals in JavaScript
- React vs Signals: 10 Years Later
- Software and its Discontents, January 2023, Part 1
- In-Depth Guide to CSS Logical Properties
- The 25 Percent Rule for Tackling Technical Debt
- React Server Components with Dan Abramov, Joe Savona, and Kent C. Dodds
Week 83
- Introducing react.dev - new React docs
- Prop drilling and component composition in React
- ENDING EVERY TYPESCRIPT DEBATE in 90 minutes
- “Thinking in React” visualized
- GPT-4 has been unleashed
- Comprehensive language-agnostic guidelines on variables naming
- A Brief History of Reactivity
Week 84
- Are you making these five mistakes when writing alt text?
- GPT-4 has been unleashed
- SPA view transitions land in Chrome 111
- TypeScript’s Migration to Modules
- All JavaScript and TypeScript Features of the last 3 years
- State in React is Immutable
- Elegantly managing state and renders in React
- The End of Front-End Development
Week 85
- Meet the top layer: a solution to z-index:10000
- Playwright’s UI Mode: Watch mode and time travel debugging
- Game over… GitHub Copilot X announced
- HTML curiosities that might surprise you… or not
- Understanding React’s types
- 6 CSS snippets every front-end developer should know in 2023
- Rethinking React best practices
- React Labs: What We’ve Been Working On – March 2023
Week 86
- Load Balancing
- Prompt Engineering Guide
- Announcing the GitHub Actions extension for VS Code
- Masterclass: AI-driven Development for Programmers
- Rich Harris: Hot takes on the web
- Make TypeScript errors prettier and human-readable in VSCode
- Setting State On An Unmounted Component
- How to Name your Types
Week 87
- The history and legacy of Visual Basic
- AWS CodeWhisperer… The Copilot Killer?
- GraphQL: From Excitement to Deception
- Fighting inter-component HTML bloat
- A gentle introduction to React, but visualized.
- What’s new in ECMAScript 2023
- An Animated Guide to Reacts Optional Parameters
- TypeScript Decorators: A complete guide
Week 88
- The Interactive Guide to Rendering in React
- Ryan Dahl on Deno 2.0
- VS Code Day 2023 playlist
- The URL is the ultimate global state management tool
- Practical Guide To Not Blocking The Event Loop
- 7 Practical CSS Typography Tips & Tricks
- Creative ways of using useReducer
Week 89
- The Evolution of React Rendering Architectures & Web Performance
- How to Write Comments in React: The Good, the Bad and the Ugly
- Write down a command-line to see the help text that matches each argument
- Building a culture of excellence | David Singleton (CTO of Stripe)
- How large DOM sizes affect interactivity, and what you can do about it
- CSS Text balancing with text-wrap:balance
Week 90
Weeks 91 - 100
Week 91
- Understanding React Concurrency
- What Is ChatGPT Doing… and Why Does It Work?
- Unveiling the Magic: Exploring Reactivity Across Various Frameworks
- The evolution of React APIs and code reuse
- Tips and tricks for working with Large Language Models like OpenAI’s GPT-4
Week 92
- State Management in React Applications
- Windows and the AI Platform Shift
- What’s new in CSS and UI: I/O 2023 Edition
- 300ms Faster: Reducing Wikipedia’s Total Blocking Time
- GraphQL and Type Systems
Week 93
- One Hour Advanced TypeScript Workshop
- React Hook Form DevTools to help debug forms with validation
- Christoph Nakazawa - How Not to Build a Video Game, React Summit 2023
- Malte Ubl - Principles for Scaling Frontend Application Development, React Summit 2023
- Some things I learnt from working on big frontend codebases
- 21 Awesome Web Features you’re not using yet
Week 94
- How to be a git expert
- How to Name your Types
- Test your React hooks with Vitest efficiently
- Teleportation in React: Positioning, Stacking Context, and Portals
- The massive bug at the heart of the npm ecosystem
- Stack Overflow Developer Survey 2023
- Modern CSS For Dynamic Component-Based Architecture
Week 95
- Modern component-driven HTML email
- Erick Wendel - Recreating a JavaScript runtime | Understand the magic behind #nodejs core
- The Concise TypeScript Book: A Concise Guide to Effective Development in TypeScript. Free and Open Source.
- The complete GraphQL Scalar Guide
- If you’re a software engineer looking to grow from anything from soft skills to technical skills, here are some newsletters you’ll find helpfu
- htmx in 100 seconds
Week 96
- Beyond Browsers: The Longterm Future of JavaScript Standards
- Git Hidden Gems - Enrico Campidoglio - NDC Oslo 2023
- JSNation 2023 Playlist
- Matan Borenkraout @ ReactNext ‘23 | Testing Library: everybody uses it, but nobody understands it
- How React 18 Improves Application Performance
- Embracing Polymorphism for Flexible Components
Week 97
- Node.js Best Practices 2023 edition
- Fix your useRefs with ElementRef
- Boring Architecture
- Future Frontend 2023 playlist
- Understanding React Server Components
- Partially Controlled Components: A Declarative Design Pattern in React
Week 98
- Unraveling the magic of Pattern Matching
- Dependency Injection, The Best Pattern
- Code Alchemy: Transpilation, Compilation, and Bundling Decoded
- Learn how multiprocessing works, what system calls really are, how computers manage memory with hardware interrupts, and how Linux loads executables.
- JS Is Weird quiz
- Why and How to Create Content as a Software Engineer
Week 99
- Things you forgot (or never knew) because of React
- A compilation of outstanding testing articles (with JavaScript)
- What helps people get comfortable on the command line?
- Quit Your YAP-ing
- Fantastic closures and how to find them in React