2021
994 posts
2021 994
December 2021
- Substrate blockchain development: Core concepts
- Optimizing task queues with Celery and Flask
- What’s new in Django v4.0
- Building a PWA with Vue.js
- Creating a Flutter audio player and recorder app
- Top WebSocket libraries for Node.js in 2022
- How to implement a shimmer effect in Flutter
- Web scraping in Python with lxml and pandas
- Python datetime module: Handling dates and time
- WeakMap and WeakSet : Understanding JavaScript weak references
- Guide to Polkadot blockchain app development and deployment
- Introduction to data science with NumPy
- Building a web scraper in Go with Colly
- Tamagui for React Native: Create faster design systems
- New features in UnoCSS: A Tailwind CSS alternative
- Creating and customizing an HTML5 video player with CSS
- React Native JWT authentication using Axios interceptors
- Build a DApp on Avalanche: A complete guide
- Build a CRUD application in React with Firebase Web SDK v9
- Building a Vue 3 component library
- Building your first DApp with Flutter and Solidity
- Next-level component showcasing with Storybook controls
- Creating animations with lottie-react-native
- Data Binding in Android: A tutorial with examples
- StateNotifier: Improving state change notifiers in Flutter
- Data visualization with D3.js and Node.js
- Using Contentful with React
- Managing state with Elf, a new reactive framework
- Create collapsible React components with react-collapsed
- Making Django migrations in Python
- What’s new in TypeScript 4.5
- Build a serverless app with Node.js and OpenWhisk
- How to build a GUI with PyQt
- Building GraphQL APIs with TypeGraphQL and TypeORM
- How to build secure smart contracts using Vyper
- Building an app with Electron and Vue
- What’s new in the latest GraphQL spec
- Redux immutable update patterns
- Run React Native background tasks with Headless JS
- React Router v6: The future of Reach Router and React Router
- Create an advanced scroll lock React Hook
- How to transpile ES modules with webpack and Node.js
- Best Node.js CMS platforms for 2022
- Using Fetch Event Source for server-sent events in React
- Responsive CSS border radius with the Fab Four technique
- Getting an element within a component with Vue querySelector
- Exploring theming in Jetpack Compose
- Python data visualization with Bokeh and Jupyter Notebook
- Guide to IPFS garbage collection
- Build an analytics app with React and Cube.js
- Using FlutterGen code generator in Flutter
- React Native Contacts: How to access a device’s contact list
- A guide to React Native Navigation
- A guide to React forms and events using Formik
- How to build animated page loaders in CSS
- Configuring the Go HTTP client
- Optimizing your app with Android Profiler
- Creating an infinite CSS background image loop
- Introduction to Flutter BLoC 8
- Deep dive into iterating, context, and children in React
- Ditch the Wrangler CLI for Miniflare
- Styling SolidJS applications using Tailwind CSS
- Build and deploy a Flask app using Docker
- How to build a type-safe React Redux app
- Creating a custom React Native dropdown
- Supporting accessibility in iOS applications
- A complete guide to null safety in Kotlin
- Top 4 Ethereum testnets for testing smart contracts
- Why you don’t need to mix routing state with Redux
- Getting started with React SyntheticEvent
- Image branding with ImageKit and Vue.js
- Implementing split view and responsive layout in React Native
- Build a GraphQL API with Python, Flask, and Ariadne
- Build an animated cloud generator with SVG and CSS
- Data visualization with Python Dash
- react-three-fiber: 3D rendering in the browser
- Building a Trello Clone with React DnD
- Concurrency patterns in Golang: WaitGroup s and Goroutines
- What you need to know about Parcel 2
- What’s new in NativeBase 3.0
- Create an Android photo app using Glide
- What’s new with WebKit in Safari 15
- Scrape a website with Python, Scrapy, and MongoDB
- Node.js task runners vs. module bundlers
- Using React Native Sensors to create a racing game
- Exploring NodeGUI and React NodeGUI: Electron alternatives
- How to implement Keycloak authentication in React
- Going serverless with Eleventy
- Implementing route guards in Flutter web apps
- Comparing Next.js and After.js for SSR React apps
- Understanding why your CSS fails
- Pollen vs. Tailwind CSS: Finding the better build experience
- PyCharm vs. VS Code: Choosing the best Python IDE
- Build a Google Analytics dashboard clone in Node.js
November 2021
- Create dynamic lists in Android with RecyclerView
- The state of P2P protocol acceptance in modern browsers
- Using tsm as a shebang interpreter in TypeScript
- How to make an HTTP POST request with a JSON body in Go
- When to use multiple endpoints in GraphQL
- Credit card form web component tutorial
- What’s new in Next.js 12
- Dependency injection in React
- Introduction to Svelte Actions
- How to receive webhooks in Python with Flask or Django
- When and how to use interfaces and classes in TypeScript
- How to build a blockchain in Rust
- How to write more readable React code
- Halfmoon tutorial: How to customize your website UI for light and dark modes
- Troubleshooting nested pages in Nuxt.js
- Creating Python REST APIs with Flask, Connexion, and SQLAlchemy
- How to create SVG maps in React with react-simple-maps
- Bidirectional CSS centering: A complete guide
- Building data stories through charts with Vizzu
- Build a sitemap generator in Next.js
- Open Graph: How to create sharable social media previews
- Dart and Flutter data structures: A comprehensive guide
- Mastering data visualization in Python with Matplotlib
- Understanding RenderObjects in Flutter
- Creating an image carousel in Flutter
- Getting started with esbuild
- Options for optimizing caching in React
- Top 5 decentralized app development frameworks
- Visualizing data in Golang with go-echarts
- Understanding the Android activity lifecycle
- Writing smart contracts with Solidity
- Exploring Motion One from Framer Motion
- Comparing Kubernetes across GKE, EKS, and Azure
- Build native UI components in React Native
- Extending CSS when / else chains: A first look
- What’s new in Nuxt 3
- Using Needle to send HTTP requests in Node.js
- Build progressive micro-frontends with Fronts
- What is Slate.js, and will it replace Quill and Draft.js?
- Using JSON in Go: A guide with examples
- How to create and deploy an ERC-20 token on the Ethereum blockchain
- What’s new with JSON in PostgreSQL v14
- Why don’t people like PHP?
- Best practices for Vuex mapping
- The complete guide to blockchain testing
- CRUD with Golang and CockroachDB
- Adding emojis to your React app
- Web3.py tutorial: A guide to Ethereum blockchain development with Python
- Best practices for stacking elements in CSS
- Should you keep the faith with React Native?
- What you need to know while using the Geolocation API
- Refactor a React app with the new Firebase v9.x Web SDK
- Fundamentals of functional programming with React
- Choosing the right gestures for your Flutter project
- Using Node.js to create an HTTP proxy for IPFS content
- Build an easy React carousel with React Slick
- Guide to blockchain game development
- Solving common issues with node-gyp
- Understanding Flutter streams
- Implementing cryptography with Python
- How to build an AR/VR app with ViroReact
- Creating React Native animated toast messages from scratch
- GraphQL subscriptions with Node.js and Express
- Introduction to SolidJS
- 5 methods to reverse a Python string
- Comparing the top Python GUI frameworks
- Marble.js vs. Express.js: Comparing Node.js web frameworks
- Getting started with react-redux-firebase
- Creating a Flutter barcode scanner
- Improving overconstrained Rust library APIs
- Kafka vs. RabbitMQ: Comparing Node.js message brokers
- Web automation with Selenium and Python
- Data visualization in Python using Seaborn
- Introduction to testing SvelteKit applications
- Configure 3D models with react-three-fiber
- Using Recharts in React to add charts
- Build a pricing component from scratch with Tailwind CSS
- JavaScript Promises: race, all, allSettled, and then
- Exploring reactive programming with Node.js
- Customize Angular lazy loading modules for multiple frontends
- Implementing localization in Svelte
- Understanding React compound components
- Intro to Python dictionaries
- Understanding TypeScript object serialization
- Automatically build and deploy a Vue.js app with GitHub Pages
- Building responsive components in Chakra UI
- Python file handling: A complete guide
- Create responsive layouts with Flexible and Expanded widgets in Flutter
- Comparing the top 3 React lightbox libraries
- Build a machine learning email spam detector with Python
- Choosing the right database for your Flutter application
- Implementing Picture-in-Picture mode on Android
- How to create your own cryptocurrency with JavaScript
- Theatre.js: Create intricate and powerful animations in JavaScript
- Using an SQL database in Golang
- Using Drizzle and React to write DApp frontends
- How to use custom fonts in Flutter
- Create and customize radio buttons in React Native
- Build a Python web scraper with Beautiful Soup
- Truffle Suite tutorial: How to develop Ethereum smart contracts
- Making HTTP requests in Rust with Reqwest
- Building a DApp with Ethers.js
- How to protect against regex denial-of-service (ReDoS) attacks
- Masonite: MVC web framework for Python
- Comparing React form builders: Formik vs. Unform
- Build your own component library with Svelte
October 2021
- Kotlin coroutine unit testing the better way
- JavaScript maps vs. sets: Choosing your data structure
- How to persist data in Flutter using SQLite
- Firebase Crashlytics: Identify bugs in React Native apps
- Learning how to use AWS Amplify in Flutter
- Decentralized data storage using IPFS and React: A tutorial with examples
- Automatically generate React components with Plop.js
- react-phone-number-input: Detecting international location
- Understanding Python dataclasses
- Comparing statically typed JavaScript implementations
- for and while loops in Python
- What we can learn from GraphQLConf 2021
- Top 7 blockchain-based databases
- Developing a 2D mobile game as a mobile app developer
- Benchmarking in Golang: Improving function performance
- Using axios.all to make concurrent requests
- Geolocation and geocoding in Flutter
- How to develop, test, and deploy smart contracts using Ganache
- 5 open source JavaScript datagrids for your next project
- Flutter Redux: Complete tutorial with examples
- How to create a Solana wallet with Go
- Intro to SQLDelight
- Using ArangoDB with React and Next.js
- Using material-table in React to build feature-rich data tables
- Working with lists in Python
- React Leaflet tutorial
- Understanding Flutter’s Timer class and Timer.periodic
- Using KeyboardAwareScrollView and KeyboardAvoidingView in React Native
- Field arguments vs. directives in GraphQL
- Top 5 smart contract programming languages for blockchain
- Learn Golang encryption and decryption
- Svelte Material UI: Advanced Material Design components
- Top form validation libraries in Svelte
- How to use Go text templates
- Running Strapi in production with AWS
- React Native SectionList tutorial with examples
- An introduction to Prisma 2
- Build a custom TikTok autoplay React Hook with Intersection Observer
- Flutter Slider widgets: A deep dive with examples
- Server-side rendering with FastAPI and MySQL
- How to integrate a Braintree payment system in React
- Containerizing Flutter web apps with Docker
- Commitlint: Write more organized code
- TypeScript vs. JSDoc JavaScript for static type checking
- A guide to blockchain consensus protocols
- Handling gestures in Flutter
- Create a React Native search bar from scratch
- Introduction to React Native Maps
- Creating and saving images with node-canvas
- React re-reselect: Better memoization and cache management
- What’s new in Gatsby v4
- Scaffolding an app with Vue 3, Nuxt, and TypeScript
- Using JavaScript’s .at() method
- Comparing React Native code coverage and testing tools
- Ethereum blockchain development using Web3.js
- Testing TypeScript apps using Jest
- Creating a Puppeteer microservice to deploy to Google Cloud Functions
- Using RxJS Observables to transform data in TypeScript
- Top 10 Vue admin dashboards
- Create and customize Flutter radio buttons
- Animations using React Hooks and GreenSock
- How to implement feature flags in React
- Using WebSockets in Flutter
- Iced.rs tutorial: How to build a simple Rust frontend web app
- Build a Bluetooth app with the Chrome Web Bluetooth API
- Using React Native Chart Kit to visualize data
- Getting started with RealmSwift
- Flutter’s DataTable widget: A guide to displaying data
- Using AppState in React Native to improve performance
- Fastify-vite: Serving Vite apps with SSR and client-side hydration
- Run React Native apps on an Android emulator for macOS
- Debugging React Native apps with Flipper
- Dockerize Node.js apps with Buildpacks
- Flutter FloatingActionButton: A complete tutorial with examples
- What’s new in Bootstrap 5.1.0
- Migrating to SWC: A brief overview
- Best practices for Node.js process management with PM2
- Comparing Node.js logging tools
- Deprecated HTML elements (and what to use instead)
- Improve custom Hook debugging with useDebugValue
- Understanding axios.create
- Building faster Android apps with Jetpack Compose
- Getting started with Storybook in Vue 3
- Comparing the best web servers: Caddy, Apache, and Nginx
- Styling Vue.js components with VueTailwind
- Comparing Go debugging tools
- Creating a website with Next.js and React
- Top 6 blockchain development frameworks
- How and when to debounce or throttle in React
- Documenting Go web APIs with Swag
- Comparing Flutter date picker libraries
- React Native Debugger: Tips for fast debugging
- Setting up email authentication with React Native, react-navigation, and Firebase
- Running Node.js scripts continuously using forever
- Strapi API creation: A quick guide
- How to build a custom calendar in Flutter
- How to implement WebSockets in React Native
September 2021
- Using CSS Modules in React Native
- Vuex showdown: Mutations vs. actions
- Using Cobra to build a CLI accounting app
- Introducing Assembler CSS, a new alternative to Tailwind CSS
- daisyUI: Tailwind CSS components for reducing markup
- Controlled vs. uncontrolled components in React
- How to detect and render device types in React
- Dynamic routing using Vue Router
- Creating a text resizing widget with CSS and JavaScript
- Building a 2D game with Flutter
- Building a PWA with Svelte
- Testing accessibility with Storybook
- A guide to pagination, load more buttons, and infinite scroll
- Using Plotly in React to build dynamic charts and graphs
- Building a Flutter video player
- Testing in Blazor: A complete tutorial
- Choosing the right progress indicators for async Flutter apps
- Intro to Apollo Server 3 and Apollo Sandbox
- Creating configuration files in Node.js using node-config
- Refactoring your Vue 2 apps to Vue 3
- A deep dive into linting in Node.js
- How to detect a click outside a React component
- Flutter modal bottom sheet tutorial with examples
- Inject dynamic content in Angular components with portals
- React Tracked: Manage state and prevent excessive re-rendering
- Creating a Flutter onboarding screen
- Build a robust React app with Husky pre-commit hooks and GitHub Actions
- Creating multi-step forms with React Stepzilla
- Sharing content in React Native apps using React Native Share
- A comprehensive guide to Svelte components with slots
- Comparing React tree components
- Using Appwrite with Flutter: A tutorial with examples
- Best practices for laying out your Flutter app
- React Hooks for infinite scroll: An advanced tutorial
- Migrating your Flutter project to null safety
- Investigating the new CSS viewport-relative units
- Understanding min-content, max-content, and fit-content in CSS
- Tree shaking and code splitting in webpack
- Gin binding in Go: A tutorial with examples
- SWR v1 is here: What’s new?
- Polymorphic relationships in Laravel and their use cases
- Build a WYSIWYG text editor using Quill
- Reflection in Go: Use cases and tutorial
- Improve mobile UI with React Native safe-area-context
- JavaScript object immutability: Object.freeze vs. Object.seal
- Flutter camera plugin: A deep dive with examples
- What’s new in Flutter 2.5
- Manage notifications in React Native with react-native-notifications
- Using the JavaScript Either monad for error handling
- Using vue-loader to create single-page applications
- Swapping GraphQL servers with the least effort
- Building flowcharts with GoJS
- How to play sounds in React Native using react-native-sound
- Working with Node.js streams
- React and Stripe payment system tutorial
- Structuring your Golang app: Flat structure vs. layered architecture
- How to use Sass in React Native
- Create reusable components with Mitosis and Builder.io
- How to use pointers in Go
- Charting in React with ApexCharts
- Best practices for using trailing commas in JavaScript
- CSS transitions: Animating a toggle button
- Build an Instagram-like infinite scrolling feed with React Query
- Getting started with vue.draggable
- Experimenting with the FullScreen API
- Implementing SVG in Flutter with flutter_svg
- How to deploy a React Native app to the Google Play Store
- How to configure CSS Modules for webpack
- File processing in Node.js: A comprehensive guide
- Create a custom tooltip component in Vue
- Full-stack Rust: A complete tutorial with examples
- Using Vue.js slots to pass HTML content to components
- Persistent login in React using refresh token rotation
- Exploring the Stripe Flutter SDK
- Authorization through access control in GraphQL
- 5 web APIs that add mobile functionality to your project
- A comprehensive guide to data structures in Go
- What’s new in Svelte: Summer 2021
- Using WebSockets in Golang
- Using SVG and Vue.js: A complete guide
- A JavaScript developer’s guide to browser cookies
- Managing SvelteKit and Shopify cart interactions
- Using GraphQL with Flutter: A tutorial with examples
- Create draggable components with React-Draggable
- Exploring Velociraptor, Deno’s npm-style script runner
- Livewire vs. Inertia.js: Comparing Laravel frontends
- What’s new in React Native v0.65
- Advanced techniques in Chakra UI
- Creating a dropdown list in Flutter
- Creating custom themes with Tailwind CSS
- Building a Svelte Native iOS app
- Using Redux Toolkit’s createAsyncThunk
- Rendering large datasets in Vue.js
- Sharing code with React Native for Web
- React Navigation vs. React Native Navigation: Which is right for you?
- A deep dive into Lefthook for React and React Native
- Deep dive into React Native Reanimated
- Exploring advanced compiler options in TypeScript
August 2021
- How to create Flutter charts with charts_flutter
- Become a LogRocket guest author
- Create a search bar in React from scratch
- Adding TypeScript to an existing Svelte project
- Implementing local notifications in Flutter
- Building a random number generator with JavaScript and Node.js
- How to use Go channels
- Deep dive into Vue event handling
- Build a React Native progress bar
- How to create a custom alert dialog in React Native
- Build an ecommerce site with SvelteKit and the Shopify Storefront API
- How to use mixins and custom functions in Vue
- Build an ecommerce app from scratch with React Native
- How to create Dart packages for Flutter
- Using Passport for authentication in Node.js
- Improve async programming with JavaScript promises
- Configuring any GraphQL server with Envelop
- Building micro-frontends with webpack’s Module Federation
- Comparing Vue.js date pickers
- Intro to the Flutter Stack widget
- Understanding JavaScript currying
- Building a responsive navbar in Tailwind CSS
- Improve async network state handling with custom React Hooks
- Why scrum has become irrelevant
- Mastering Stripe PaymentSheet in React Native with Expo
- Astro: Build faster apps with less JavaScript
- Storing credentials using react-native-keychain
- Make sharing TypeScript code and types quick and easy
- 7 most common web design mistakes according to psychology
- The ultimate guide to Vue Router
- Adding videos to React Native with react-native-video
- CSS margin vs. padding
- How to display a SnackBar in Flutter: A tutorial with examples
- Achieving lazy hydration in Vue 3 from scratch
- Using aliases in GraphQL
- How to use React with Ruby on Rails
- How to use Flutter Hooks
- Using React Query for state management in React Native
- Creating Victory charts in React Native
- Advanced unit testing patterns in Go
- A complete guide to enum classes in Kotlin
- A quick guide to Provider for Flutter state management
- How to build an app with Hugo
- Creating an offline-first React Native app
- Type flowing: Rethinking the TypeScript typing system
- Top React Native tab navigation components
- Implementing CodePush in React Native
- The Web Animations API vs. CSS
- vanilla-extract tutorial: Create zero-runtime style sheets in TypeScript
- Using Vuex 4 with Vue 3
- Implementing user registration and authentication with Strapi and Next.js
- Managing app permissions in React Native
- How to create a search bar in Flutter
- How to send emails from a React app with Netlify Functions
- Level up your CSS linting using Stylelint
- How to authenticate and access Google APIs using OAuth 2.0
- Laravel Breeze’s Inertia-React stack vs. Next.js and Gatsby
- Creating a scalable GraphQL API with MySQL, Node.js, and Apollo
- Pagination components with React and Tailwind CSS
- Store and retrieve precise monetary values in JavaScript with Dinero.js
- Using SharedPreferences in Flutter to store data locally
- Building an authentication API with NextAuth.js
- Mastering the Node.js path module
- The best webpack configurations for React applications
- 5 things not to do when building React applications
- A guide to theming your app in Flutter
- Building iOS apps with SwiftUI: A tutorial with examples
- Creating Duplex streams in Node.js
- Integrating GraphQL in a Blazor application
- Creating a Chrome extension with React and TypeScript
- Build a Google Classroom clone with React and Firebase
- Creating a custom REPL for Node.js
- Using RxJS operators to consume Observables
- Building charts in React with Nivo
- Using Uniform CSS to build modern UI
- 1 week with GitHub Copilot: Building an app using only Copilot
- NativeScript vs. React Native
- An in-depth look at cropping images in CSS
- Organizing TypeScript code using namespaces
- Improving TypeScript error handling with exhaustive type checking
- Firestore in Swift tutorial
- Managing DOM components with ReactDOM
- React-Calendar: Build and customize a simple calendar
- Handling local data persistence in Flutter with Hive
- Stackblitz WebContainers: Run Next.js inside the browser
- The best new Vue 3 UI libraries of 2021
- Understanding Flutter navigation and routing
- A complete guide to TextInput in React Native
- Writing JS-based Bash scripts with zx
- Implementing Okta authentication in a React app
- Build a profanity filter API with GraphQL
- Create a performant virtual scrolling list in Vue.js
- Integrate GraphQL into Python using Ariadne
- UI/UX best practices for cookie notifications
- Is SVGO worth it?
- Adding AMP components to a Next.js webpage
- Improving microservice architecture with GraphQL API gateways
- Using Gatsby with Tailwind CSS: A tutorial with examples
- Server-side A/B testing with Node.js
- A deep dive into unit testing in Go
- The ultimate guide to authentication in Vue.js with Supabase
- Going serverless with Node.js apps
July 2021
- Using the inbuilt Node.js profiler
- How to build iOS apps using React Native
- Automatically generate and release a changelog using Node.js
- Performance improvements for mobile apps in Flutter
- 5 things you didn’t know you can do in CSS-in-JS
- Build a GraphQL + React app with TypeScript
- How to create a framework in Swift
- Comparing React Native state management libraries
- React slider tutorial using react-slider
- Using the React.cloneElement() function to clone elements
- Reading and writing XML in Node.js
- Bringing SVGs to Three.js with SVGLoader
- Uncommon HTML tags that improve web semantics
- How to make a splash screen in Flutter
- Render webpages using Flutter WebView
- Building an image picker in Flutter
- Building faster webpages for Core Web Vitals
- Creating a navbar in React
- Exploring JIT mode in Tailwind CSS
- Using Sequelize with TypeScript
- Parsing HTML in Node.js with Cheerio
- Build a CRUD API using the Google Sheets API
- Top 5 TypeScript dependency injection containers
- Testing Vue.js components with Vue Test Utils
- Building an animated loader in React Native
- How to add SliverAppBar to your Flutter app
- Creating contact forms with the Notion API and Next.js
- Implementing scroll restoration in ecommerce React apps
- Write more readable code with TypeScript 4.4
- Deep dive into JavaScript event bubbling and capturing
- Understanding JavaScript decorators
- How to safely render Markdown using react-markdown
- React Native Web vs. Flutter web
- Adding dynamic meta tags to a React app without SSR
- Configuring JSON for Go
- How to virtualize large lists using react-window
- Dependency injection in Vue: Advantages and caveats
- Drag and drop UI elements in Flutter with Draggable and DragTarget
- Type coercion in JavaScript
- Ditching try...catch and null checks with Rust
- Using setState in React components
- Provider vs. Riverpod: Comparing state managers in Flutter
- Debugging your app with React Native Debugger
- Choosing when to build a custom React component library
- Building a VR app with React 360
- React Final Form: A library for more performant forms
- Securing GraphQL API endpoints using rate limits and depth limits
- Renovate: Dependency updates on steroids
- Redux vs. MobX: Which performs better?
- CSS inheritance: inherit, initial, unset, and revert
- Implementing copy-to-clipboard in React with Clipboard API
- React Native for desktop using React Native for Windows
- How to build a React accordion menu from scratch
- Networking in Flutter using the http package
- TypeScript, abstract classes, and constructors
- Error handling in Swift
- Creating hover events with SyntheticEvent and React Hover
- Using Firebase Cloud Messaging as a pub/sub service
- Incorporating elastic ease in CSS animations
- React Hook Form vs. Formik: A technical and performance comparison
- Achieving responsive design in Flutter
- Getting started with PeerJS
- Crafting authentication schemes with Prisma in Express
- Build a location analytics reporting API in Node.js
- Building a Next.js shopping cart app
- Using Big O notation to improve app performance
- Benefits of using styled-components in React
- Fundamentals for using structs in Rust
- Authenticate your Next.js application using Auth0
- Adding drag-and-drop functionality with react-beautiful-dnd
- How to deploy Next.js on Google Cloud Run
- Caching images in React Native: A tutorial with examples
- Build a React Native component library with Storybook
- Concurrency in Swift: Using the new async/await syntax
- Pinia vs. Vuex: Which state management library is best for Vue?
- Improving performance with HTML responsive images
- Implementing react-input-mask for web apps
- Data fetching with React Native
- Magic login links with Laravel
- How to build an image picker using react-native-image-crop-picker
- Flutter vs. Swift for iOS development
- Creating a chat application with WebRTC
- Getting started with the Notion API
- Run animations in React and React Native from one codebase
- A guide to CSS animations using clip-path()
- A complete guide for leveling up your CSS selector skills
- Including both PHP 7.1 and 8.0 code in the same plugin … or not?
- The difference between stateless and stateful widgets in Flutter
- Internationalization and localization in React Native
June 2021
- React localization with i18next
- Exploring Supabase, the open source Firebase alternative
- 5 GraphQL clients for JavaScript and Node.js
- Understanding Swift schedulers
- Add Firebase to your Flutter app with FlutterFire plugins
- Networking in Flutter using Dio
- Form validation in Svelte
- New features in Next.js 11
- How to debug Node.js apps in Visual Studio Code
- Implementing 3D Secure in Stripe
- Grand Central Dispatch tutorial
- How to develop cross-platform desktop apps with JavaScript and Go
- Building an application with React and Nx
- Getting started with React Native and Expo SDK
- Building mobile apps with Vue Native
- Async callbacks with Flutter FutureBuilder
- Understanding SharedArrayBuffer and cross-origin isolation
- Nodemon tutorial: Automatically restart Node.js apps with Nodemon
- Understanding $nextTick in Vue.js
- webpack or esbuild: Why not both?
- Guide to CSS animation for JavaScript developers
- React Hooks: The good, the bad, and the ugly
- Mastering Swift fundamentals
- How to add Font Awesome to an Angular project
- Comparing Vue.js to new JavaScript frameworks
- A complete guide to Kotlin lambda expressions
- Intro to React Native Camera
- Creating a pop-up modal in React Native
- Guide to custom React Hooks with MutationObserver
- Create a fitness tracker with React and Firebase
- Exploring the new Stripe React Native SDK
- How browser rendering works — behind the scenes
- Essential transitions and animations in Svelte
- Overriding dependencies in the Angular injector hierarchy
- Getting started with Stripe Connect using Next.js
- How to build a gRPC server in Dart
- Sapper and Svelte: A quick tutorial
- Code testing and linting using AVA and XO
- Refactoring cascading conditionals in favor of readability
- React Intl: Internationalize your React apps
- Swift extensions: An overview with examples
- Terser vs. Uglify vs. babel-minify: Comparing JavaScript minifiers
- Theming React components with Tailwind CSS
- Getting started with React Cosmos
- Build a Rust + WebAssembly frontend web app with Yew
- Type casting in Swift
- Building a card widget in Flutter
- How to create a grid list in Flutter using GridView
- tinyhttp vs. Express.js: Comparing Node.js frameworks
- Creating dialogs in Flutter
- Designing a URL-based query syntax for GraphQL
- Using Xamarin.Essentials to manage phone calls and SMS
- How to use scroll-linked animations the right way
- How to create NFTs with JavaScript
- Deploying single-page Angular apps to GitHub Pages
- Introduction to classes and structs in Swift
- Scaling your Node.js app using distributed queues
- How to implement AdMob in React Native with Firebase
- Using styled-components in TypeScript: A tutorial with examples
- for-in loops in Swift tutorial
- Keeping mistakes away from production
- How to use TypeScript with React 18 alpha
- React Icons: A comprehensive tutorial with examples
- The ultimate guide to enabling Cross-Origin Resource Sharing (CORS)
- Implementing swiper components in React Native
- Create React App: A quick setup guide
- Cloudflare Pages tutorial: Deploying a React app via GitHub
- Upgrade your CSS layouts with Atomic Layout
- Comparing React Native analytics tools
- Displaying images with the React Native Image component
- Laravel Dusk browser testing and automation
- A deep dive into CSS Module
- Crafting product tours in Vue.js
- Handling side effects in an Angular + Redux application
- Firebase and Fauna: Comparing database tools for frontend devs
- Creating a CLI tool with Node.js
- Know your JavaScript data structures
- Understanding protocols in Swift
- Docker volumes vs. bind mounts
- How to build a basic flexbox layout: A tutorial with examples
- Simplify React state management with Hookstate
- Using Kotlin data classes to eliminate Java POJO boilerplates
- Essential VS Code extensions for Flutter
- Handling authentication in Vue.js using Vuex, Vue Router, and Auth0
- How to create a Deno plugin in Rust
- Balancing information density in web development
- Parsing raw text inputs in web applications using ANTLR
- Content management in Next.js with Sanity CMS
- What’s new in Recoil 0.3?
- Building React Native applications with Styled System
- Server-side rendering with Vue and Nuxt.js
May 2021
- Building extensible PHP apps with Symfony DI
- SSG vs. SSR in Next.js
- Debugging React performance issues with Why Did You Render
- Theming Vue.js with styled-components
- Swift enums: An overview with examples
- Using MobX for large-scale enterprise state management
- Converting tables to grids with React compound components
- Understanding Kotlin coroutines
- Exploring SvelteKit, the newest Svelte-based framework
- A complete guide to OkHttp
- Building a multi-tenant Amplify app with a React frontend
- Using npm to create JavaScript icon libraries
- How to set up your own PaaS with CapRover
- Intro to Clio lang: Ship performance-critical JS with ease
- Node.js best practices and performance analytics in 2021
- Implementing Firebase Authentication in a Flutter app
- A detailed look at basic SQL.js features
- useState vs. useRef : Similarities, differences, and use cases
- Laravel and Docker: A guide to using Laravel Sail
- Optimize React apps using a multi-layered structure
- How to use Bulma CSS with React
- How to integrate PayPal payments with React Native
- How to build a simple game in React Native
- Tips for transpiling code from PHP 8.0 down to 7.1
- Build a Slackbot in Node.js with Slack’s Bolt API
- Building cross-platform desktop apps with Svelte, Electron, and Reloadly
- Testing your React Native app with Appium
- State management in Flutter using the BLoC design pattern
- Why you should use Tailwind CSS with React Native
- Using Angular DataTables to build feature-rich tables
- Using Firebase Authentication in NestJS apps
- Creating physics-based animations in React with renature
- Why I (finally) switched to urql from Apollo Client
- Using TypeScript with React Native
- Comparing TypeScript and PropTypes in React applications
- Understanding inheritance and other limitations in Rust
- How to run SQL Server in a Docker container
- Filtering QuerySets dynamically in Django
- Creating a Node CLI with Enquirer
- A guide to features and updates in React DevTools
- How dependency injection works in Angular
- Getting started with Go for frontend developers
- Logging and remote error reporting in mobile apps
- JavaScript testing: 9 best practices to learn
- Why mentorship in tech is important
- Real-time data transfer with Socket.io
- Using React Hooks for state management
- Introduction to using Dart in Flutter
- Intro to Twin: Combining the best of Tailwind and CSS-in-JS
- Deploying a full-stack Node.js + React app for free with Begin
- Using SVG vs. Canvas: A short guide
- Angular modules: Best practices for structuring your app
- CSS custom properties as of 2021
- Angular state management made simple with NgRx
- Lazy loading using the Intersection Observer API
- Building a tag input field component for React
- Deploying a serverless API to AWS with Claudia.js
- 10 best practices for REST API design
- Intro to KubeVela: A better way to ship applications
- Top React Native boilerplates for 2021
- Server-side pagination in Angular with ngx-pagination
- Building multi-step wizards with Formik and React Query
- Demystifying Cargo in Rust
- Using state machines with XState and React
- Understanding computed properties in Vue.js
- Flutter state management methods: An overview
- Getting started with lit-html and LitElement
- What’s new in React Hook Form V7
April 2021
- Angular In-memory Web API tutorial: Mocking CRUD APIs in Angular
- Machine learning in Rust using Linfa
- How to test code that depends on external APIs in Node.js
- Widgets: The building blocks of Flutter apps
- Building a reusable auth flow in React Native
- Xcode for React Native developers: Tutorial and best practices
- JavaScript iterators and generators: A complete guide
- QuerySets and aggregations in Django
- Bridging the native app gap with Project Fugu
- Migrate a Flutter mobile app to the web: Tutorial with examples
- Understanding common frustrations with React Hooks
- What’s new in Next.js 10.1
- Project Fugu: 5 new APIs to try out in your PWA
- An introduction to profiling a Rust web application
- Creating cross-platform apps with NW.js
- The ultimate guide to text fields in Flutter
- What’s new in React Native 0.64
- Using WebSockets with Deno
- Why you shouldn’t compare Blazor to other JavaScript SPA frameworks
- What to expect from Crystal 1.0
- Adding animations to your Flutter app
- What’s new in TypeScript 4.2
- The best React Native libraries for leveraging native features
- 3 services to deploy your Node.js app for free
- Simplify GraphQL requests with React Query, GraphQL Code Generator, and TypeScript
- Boost your productivity with TypeScript project references
- CRUD with React and GraphQL: A complete tutorial with examples
- Top Express.js template engines for dynamic HTML pages
- Remotion: A framework for making videos in React
- React lifecycle methods: An approachable tutorial with examples
- A closer look at the CSS aspect-ratio property
- Lazy loading components and code splitting in Vue.js
- Laravel Passport: A tutorial and example build
- JavaScript generators: The superior async/await
- Redux isn’t dead
- Comprehensive guide to using Redux in React Native
- Using react-responsive to implement responsive design
- HTTP caching in GraphQL
- What’s new in Grommet v2
- Getting started with Budibase
- Why you should use an Electron alternative
- Building cross-platform apps with Expo instead of React Native
- What’s new in Vite 2.0
- Error prevention in web development
- WebAssembly runtimes compared
- Understanding ownership in Rust
- The case for using frameworks
- Creating charts in Node.js with billboard.js
- Jamstack in 2021: Past, present, and future
- Using stacked pull requests in GitHub
- Using ECMAScript modules (ESM) with Node.js
- Using React Hooks to create sticky headers
- Getting started with CollectionView in Xamarin.Forms
- Using Fuse.js to add dynamic search to a React app
- Using Font Awesome 5 with React
- How to build a custom grid with SASS
- Top utility-first CSS frameworks
- Best practices for loading fonts in Vue
- TypeScript mixins: Examples and use cases
- Writing VS Code extensions in JavaScript
- Handling and dispatching events with Node.js
March 2021
- How to adopt Next.js into your existing application
- JavaScript Reference Guide: JS module ecosystem
- Customizing the AppBar in Flutter: An overview with examples
- Comparing Vue.js mobile app development frameworks
- How to create a split pane component in React
- Automated testing in Flutter: An overview
- Getting started with Gridsome
- Implementing in-app purchases in React Native
- How to debug encrypted network traffic in React Native
- New ES2021 features you may have missed
- Angular lifecycle hooks explained
- How to fix layout shifts to improve SEO in Next.js apps
- How to send emails with Node.js using SendGrid
- What’s new in Relay v11
- Hosting all your PHP packages together in a monorepo
- Simplify proxy state with Valtio
- Continuous deployment of React Native app with Azure DevOps
- The modern guide to React prop types
- Understanding the SwiftUI grid layout
- Generating and integrating OpenAPI services in a React app
- Creating ListViews in Flutter
- Handling JavaScript errors in React with error boundaries
- SAP Commerce Cloud vs. Shopify: A comparison for store owners
- Getting started with JavaScript for PHP developers
- Code splitting in React: An overview
- Roda, the routing tree web toolkit: A tutorial
- Using vno to configure a Vue app
- What’s new in Gatsby 3.0
- React Router with Redux: Understanding navigation state
- Top testing libraries for React in 2021
- What’s new in Flutter 2.0
- Using React Native Elements, a cross-platform UI toolkit
- Handling conflict on a software engineering team
- Using CDNs to optimize website performance
- Successful refactoring with React Testing Library
- Using Elasticsearch, Logstash, and Kibana with Go applications
- CSS transitions in Nuxt.js: An overview
- Using Eleventy to host your blog
- Serverless deployments via Vercel using Node.js
- Scalable state management with Vuex and Nuxt.js
- How to create a full-bleed layout using CSS grid
- Using the React Speech Recognition Hook for voice assistance
- AdonisJs vs. Django: Which web framework should you use?
- What’s new in Cypress 6.0
- Top 10 podcasts for web developers in 2021
- JavaScript garbage collection: Browser vs. server
- Drawing shapes in Flutter with CustomPaint and Shape Maker
- Using flexbox in React Native
- Rust internationalization, localization, and translation
- Intro to ForgoJS, an ultra-lightweight UI runtime
- First look at Aleph.js: A new React framework in Deno
- Don’t underestimate the model in MVC
- The noob’s guide to useState
- Using GSAP 3 for web animation
- What’s new in Snowpack v3
- Using ES modules in Node.js
- Parallelism, concurrency, and async programming in Node.js
- The latest features of CSS in 2021
- Building a video on demand application using Gatsby and AWS
- Comparing the best new JavaScript frameworks to React
- Use cases for visual programming environments today
- Django Channels and WebSockets
February 2021
- Deep dive into Laravel Livewire
- New Material buttons in Flutter
- Send bitcoin from your wallet using JavaScript
- Using Dexie.js in React apps for offline data storage
- What is Vlang? An introduction
- React Native and Expo SecureStore: Encrypt local data
- Flutter TabBar: A complete tutorial with examples
- How to auto-deploy frontend applications to Surge using continuous deployment
- Build mobile applications with Fuse Open and JavaScript
- Managing network connection status in React Native
- What’s new in Go 1.16
- The top JavaScript data visualization libraries for 2021
- Switching from Rust to TypeScript (and vice versa)
- Creative text styling with the CSS mix-blend-mode property
- Build a reusable React component to export arrays to Excel
- Mirage JS tutorial: Mocking APIs in React
- Tips for creating your first Rector rule to transform PHP code
- React.memo vs. useMemo : Major differences and use cases
- Gridsome vs. Nuxt.js: Comparison and tutorial with examples
- How polymorphic JavaScript functions affect performance
- Changes coming to webpack in 2021
- WMR: The Swiss Army knife for web apps
- Vue Composition API vs. React Hooks
- Using WebSocket subscriptions without queues
- What’s new in React Query 3
- RTK Query: The future of data fetching and caching for Redux
- The top React table libraries to use in 2021
- Using Storybook to develop React components faster
- Caching with HttpInterceptor in Angular
- Managing React state with Zustand
- AWS Amplify: A review of advanced features
- Why you should turn your app into a PWA
- Vite vs. Snowpack: A comparison of frontend build tools
- Theming in Next.js with styled-components and useDarkMode
- You’re wrong about singletons
- How to debug Wasm and achieve a reliable stack trace
- Creating compound components in React and Angular
- Vlang vs. Rust: Comparing build languages
- React is a black box. Why does that matter?
- Debugging Rust apps with GDB
- Logging with Pino and AsyncLocalStorage in Node.js
- A comprehensive guide to JavaScript expressions and operators
- Why Flutter is overtaking React Native
- Best JavaScript machine learning libraries in 2021
- Understanding relative CSS units
- SOLID principles: Single responsibility in JavaScript frameworks
- Using Redis in AdonisJs for data caching
- How to use Rockpack
- Using Storybook and Mock Service Worker for mocked API responses
- Styling a Vue.js application using CSS
- Pug.js tutorial: A beginner’s guide with examples
- Serverless authentication services compared
- CI/CD and React: Create a pipeline using Heroku and CircleCI
- Macros in Rust: A tutorial with examples
- Making CSS animations using a sprite sheet
- Working with classes in curtains.js
- Build a full-stack React app with zero configuration
- How to use uvu: A fast and lightweight test runner
- Build a bar chart library with web components
- Magnus UI tutorial: Building out React Native UI components
- Controlling tooltips & pop-up menus with components in React
January 2021
- Next.js Commerce: An overview and tutorial
- GraphQL Modules tutorial: How to modularize GraphQL schema
- Best practices for managing and storing secrets in frontend development
- Why is Rust so popular?
- Rust and TUI: Building a command-line interface in Rust
- Using Nightwatch.js to write end-to-end tests
- Static site generation with React from scratch
- Framework7 vs. Ionic: Comparing Cordova frameworks
- Beyond the hashtag: Applying semiotics to web design
- Building a RESTful API in Deno with Oak and MongoDB
- So you think you should stop using React? Here’s why you’re wrong
- Unsafe Rust: How and when (not) to use it
- Top 10 VS Code extensions for 2021
- Building a selectable header data table with Vue.js and Vuetify
- Using D3 data visualization to create a calendar app
- Using Firebase Emulator Suite and React for local-first development
- 6 CSS micro frameworks compared
- How to set up a GraphQL API using Serverless and React
- Angular 11: What to expect when you upgrade
- Styled-components vs. Emotion for handling CSS
- Creating transitions in your Vue app with Vue Router
- Make any SVG responsive with this React component
- How to design highly performant animations and micro-interactions
- Introduction to MobX with React
- What happened to web components?
- How to use Shared Element Transition with React Navigation v5
- Use Django REST Framework to build a blog
- Dynamism and CSS calculations
- Microsoft’s Fluid Framework: An introduction
- Should you drop support for Internet Explorer 11?
- 5 CSS properties and values that are incompatible
- How and why to use React Frontload
- What is Deno, and how is it different from Node.js?
- Electron-forge vs. electron-react-boilerplate
- Node.js crypto module: A tutorial
- Supporting opt-in nested mutations in GraphQL
- What’s new in Bablyon.js 4.2
- Using FastAPI to get updates from GitHub to Telegram
- Organize code in TypeScript using modules
- Immer and Immutable.js: How do they compare?
- Using Zappa and AWS Lambda to deploy serverless Django apps
- Color picker libraries to use in 2021
- Sanity CMS for headless content management in Gatsby
- Coupled, decoupled, and headless CMS platforms
- Deploying FastAPI applications to Vercel
- Build your own styled-components library
- Graphery SVG (gySVG): An introduction
- Using Figma variants for better error handling design
- WP-CLI tutorial: How to deploy WordPress
- Using React Spring for animation: Context and examples
- The bleeding edge of JavaScript classes
- Avoiding common mistakes in React Hooks
- How to access the correct this inside a callback
- Using Bootstrap components with custom JavaScript
- Jotai vs. Recoil: What are the differences?
- Configuring Cloud Firestore in AdonisJs for CRUD requests
- Speed up JavaScript builds with spack bundler in Rust
- Containerizing a simple Django application with Docker and Docker Compose
- Debug CSS Grid with Chrome DevTools
- The JavaScript Record and Tuple proposal: An overview
- How to use Tailwind CSS in React to configure Create React App
- A complete guide to forms in Vue.js
- Building a file upload component with react-uploady and Ant Design
- Cypress vs. Selenium: Why Cypress is the better option
- Custom events in JavaScript: A complete guide