Threading vs Multiprocessing in Python
Understand the Python GIL and pick the right concurrency tool: when threads help with I/O, when processes help with CPU, and how to use concurrent.futures.
·7 min read · #python#concurrency#intermediate
#intermediate
442 posts · page 8 of 10
TanStack Query (React Query) for Data Fetching
Learn how TanStack Query replaces useEffect-based data fetching with caching, background refetching, and request deduplication that scales to real apps.
·6 min read · #react#data-fetching#intermediate
React Router Basics with Data Router APIs
Learn React Router's modern data APIs. Install, create a browser router, define routes, navigate with Link and useNavigate, and use loaders and actions for data.
·6 min read · #react#routing#intermediate
React Server Components: How They Actually Work
A clear, practical explanation of React Server Components: the runtime model, the boundary between server and client, data fetching, and the tradeoffs.
·6 min read · #react#server-components#intermediate
React Suspense and Lazy Loading Components
Use React.lazy and Suspense to code-split a React app, design fallback UI, place boundaries thoughtfully, and understand how Suspense extends to data fetching.
·6 min read · #react#performance#intermediate
useMemo and useCallback in React: When You Actually Need Them
A practical guide to React's useMemo and useCallback hooks, covering referential equality, when memoization helps performance, when it backfires, and how to profile first.
·6 min read · #react#performance#intermediate
useReducer in React and Why It Beats useState Sometimes
Understand React's useReducer hook, its signature, action shape, when to migrate from useState, and how to build a small state machine pattern for predictable UI logic.
·7 min read · #react#state-management#intermediate
Zustand: Minimal State Management for React
Skip the reducer boilerplate. Zustand gives React apps a tiny global store with hooks, selectors, and middleware in fewer than 100 lines of API.
·5 min read · #react#state-management#intermediate
Cargo Basics: Building, Testing, and Publishing Rust Code
A practical tour of Cargo — creating projects, managing dependencies and features, running tests, building release binaries, and using workspaces.
·6 min read · #rust#cargo#intermediate
Rust Collections: Vec, HashMap, and HashSet
A hands-on tour of Rust's core collections — Vec, HashMap, and HashSet — with common operations, iteration patterns, and ownership gotchas.
·6 min read · #rust#collections#intermediate
Rust Error Handling with Result and the ? Operator
A practical guide to error handling in Rust covering Result, the ? operator, unwrap and expect, custom error types, and the thiserror and anyhow crates.
·5 min read · #rust#error-handling#intermediate
Rust Structs and Enums: Modeling Data Safely
Learn how to model domain data in Rust with structs and enums, use pattern matching exhaustively, and lean on Option and Result for safety.
·5 min read · #rust#structs-enums#intermediate
Rust Traits: Shared Behavior Without Inheritance
Understand how Rust traits define shared behavior, with default methods, trait bounds, derive, and a clear take on dyn Trait versus impl Trait.
·6 min read · #rust#traits#intermediate
Postgres EXPLAIN and Practical Query Tuning
Learn how to read Postgres EXPLAIN and EXPLAIN ANALYZE output, spot expensive operations, and apply practical indexing and rewrite techniques to speed up queries.
·6 min read · #postgres#performance#intermediate
Database Normalization: 1NF, 2NF, 3NF Made Practical
A practical guide to database normalization with real customer and order examples. Covers 1NF, 2NF, 3NF, when to denormalize, and tradeoffs.
·6 min read · #sql#schema-design#intermediate
SQL Window Functions: ROW_NUMBER, RANK, and LAG
Learn SQL window functions with practical examples. Covers ROW_NUMBER, RANK, DENSE_RANK, LAG, LEAD, running totals, and the OVER clause in depth.
·6 min read · #sql#window-functions#intermediate
Tailwind Dark Mode: class Strategy Done Right
Set up dark mode in Tailwind with the class strategy, persist the choice in localStorage, and avoid the flash of wrong theme on first paint.
·5 min read · #tailwind#dark-mode#intermediate
System Design: Design a Distributed Cache (Redis-like)
Design a distributed in-memory cache like Redis or Memcached. Covers consistent hashing, replication, eviction, persistence, and surviving node failures cleanly.
·6 min read · #system-design#caching#intermediate
System Design: Design a Load Balancer
Design a layer 4 and layer 7 load balancer. Covers algorithms, health checks, sticky sessions, TLS termination, and surviving traffic spikes without dropping connections.
·5 min read · #system-design#load-balancer#intermediate
System Design: Design a Message Queue (Kafka-like)
Design a durable message queue like Kafka or Pulsar. Covers partitions, replication, consumer groups, ordering guarantees, and exactly-once semantics in practice.
·5 min read · #system-design#messaging#intermediate
System Design: Design a URL Shortener (TinyURL/Bit.ly)
Design a URL shortener like TinyURL or Bit.ly. Covers ID generation, storage, read-heavy scaling, caching, analytics, and tradeoffs you should defend in an interview.
·5 min read · #system-design#url-shortener#intermediate
Progressive Web Apps (PWA): What They Are and When To Build One
A practical introduction to PWAs: manifests, service workers, offline caching, install prompts, and when a PWA is the right choice versus a native app.
·6 min read · #pwa#service-workers#intermediate
Web Accessibility WCAG Essentials Every Dev Should Know
A practical guide to the WCAG fundamentals: semantic HTML, keyboard support, contrast, focus management, and ARIA used responsibly.
·5 min read · #accessibility#wcag#intermediate
Web Vitals Explained: LCP, INP, CLS in Plain English
What Largest Contentful Paint, Interaction to Next Paint, and Cumulative Layout Shift measure, how to read them, and the practical fixes that move each one.
·5 min read · #performance#web-vitals#intermediate
Integration Tests vs Unit Tests: The Right Mix
A practical look at integration testing alongside unit tests, covering fixtures, real databases in tests, and the right balance with examples in pytest and vitest.
·6 min read · #testing#integration-tests#intermediate
TypeScript Branded Types for Nominal Typing
Add nominal typing to TypeScript using branded types so you cannot accidentally mix UserId, OrderId, raw strings, or money values.
·6 min read · #typescript#branded-types#intermediate
TypeScript Decorators: The 2026 Standard Decorators
Understand TypeScript's modern standard decorators: how they differ from the legacy proposal, the context API, and practical class and method examples.
·6 min read · #typescript#decorators#intermediate
Astro Content Collections: Type-Safe Markdown
A practical guide to Astro content collections — defining a zod schema in src/content/config.ts, using the glob loader, fetching entries with getCollection, and building a dynamic [...slug].astro route.
·8 min read · #astro#intermediate#content
Deploy to Production with GitHub Actions
A practical guide to production deploys with GitHub Actions — environments, secrets, OIDC, deploy-on-tag vs deploy-on-main, and pushing images to AWS, Vercel, or Fly.
·9 min read · #cicd#github-actions#intermediate
Django Models and the ORM
A practical tour of Django's ORM — defining models, common field types, makemigrations and migrate, QuerySet filtering, foreign keys, and simple aggregations.
·8 min read · #django#intermediate#orm
Django Views, URLs, and Templates
Wire Django models to web pages — function-based views, render(), URL routing with path(), template tags like {% for %} and {% if %}, and template inheritance with {% extends %}.
·9 min read · #django#intermediate#views
Docker: Environment Variables and Secrets
How to feed configuration into Docker containers without baking it into the image — ENV vs ARG, --env-file, Compose env, BuildKit secret mounts, and Docker Swarm secrets, with safe defaults.
·8 min read · #docker#intermediate#config
Text Embeddings: The Foundation of Semantic Search
What an embedding is, why cosine similarity works, how dimensionality and chunking choices affect retrieval, and a tiny numpy example you can run in your head.
·7 min read · #rag#embeddings#ai
Vector Databases: A Practical Overview
Why a normal database struggles with vector search, how ANN indexes like HNSW and IVF work, and a clear comparison of pgvector, Qdrant, Pinecone, Chroma, and Weaviate so you can pick one.
·8 min read · #rag#vector-db#ai
FastAPI: Async Routes and Dependency Injection
A practical guide to async path operations and Depends() in FastAPI — when async actually helps, per-request DB sessions, auth dependencies, and how sub-dependencies compose.
·8 min read · #fastapi#python#intermediate
FastAPI + SQLAlchemy: Your First Database-Backed API
A practical guide to FastAPI with SQLAlchemy 2.0 — typed models with Mapped and mapped_column, sessionmaker, get_db dependency, CRUD endpoints, and where Alembic fits.
·9 min read · #fastapi#python#intermediate
FastAPI Routes and Pydantic Models
A practical guide to FastAPI routing and Pydantic v2 — path operations, path/query/body parameters, model validation, response_model, and response_model_exclude_unset.
·8 min read · #fastapi#python#intermediate
Git Rebase Explained: When to Rebase and When to Merge
A deeper look at git rebase — the mechanics, interactive rebase with squash/fixup/edit/drop, the golden rule of published branches, conflict resolution, and rerere for repeated conflicts.
·10 min read · #git#intermediate#workflow
Arrays: Common Operations and Patterns
The everyday array patterns every DSA learner should know — traversal, linear search, insertion, deletion, reversal, rotation, prefix sums, Kadane's preview, and the one-pass habit.
·11 min read · #dsa#arrays#intermediate
Arrays: 10 Practice Problems with Solutions
Ten classic array interview problems with examples, approach, complexity, and clean Python solutions — Two Sum, Best Time to Buy/Sell Stock, Kadane's, Rotate Array, Product Except Self, and more.
·13 min read · #dsa#arrays#practice
Binary Tree Traversals: Inorder, Preorder, Postorder, Level-Order
A practical guide to the four canonical binary tree traversals — recursive and iterative versions, when to use each, and the patterns that make them click.
·7 min read · #dsa#trees#intermediate
Binary Trees: 8 Practice Problems with Solutions
Eight classic binary tree interview problems with examples, approach notes, and clean Python solutions — max depth, same tree, invert, symmetric, path sum, LCA, validate BST, and serialize/deserialize.
·9 min read · #dsa#trees#practice
Bit Manipulation: Tricks and 6 Practice Problems
Six classic bit manipulation problems — Single Number, Number of 1 Bits, Power of Two, Counting Bits, Missing Number, Reverse Bits — plus the tricks that make them tick: n & (n-1), n & -n, and XOR cancellation.
·9 min read · #dsa#bit-manipulation#practice
Dynamic Programming: 8 Classic Problems with Solutions
Eight classic dynamic programming problems — Climbing Stairs, House Robber, Coin Change, LIS, Word Break, 0/1 Knapsack, Edit Distance, and LCS — each with Python solutions and DP tables.
·10 min read · #dsa#dynamic-programming#practice
Dynamic Programming: Memoization and Tabulation
An introduction to dynamic programming — overlapping subproblems, optimal substructure, top-down memoization, and bottom-up tabulation, with worked examples in Python.
·8 min read · #dsa#dynamic-programming#intermediate
Graph Traversals: BFS and DFS
A practical guide to BFS and DFS on graphs — recursive and iterative DFS, BFS with a deque, shortest paths on unweighted graphs, connected components, cycle detection, and five classic practice problems.
·11 min read · #dsa#graphs#intermediate
Greedy Algorithms: When Locally Best Wins Globally
An introduction to greedy algorithms — when the locally best choice gives a globally optimal answer, when it doesn't, the exchange argument, and six classic problems.
·8 min read · #dsa#greedy#intermediate
Hashing and Hash Maps in DSA
How hash functions, hash maps, and hash sets work — the intuition behind buckets and collisions, chaining vs open addressing, average and worst-case complexity, and the Python containers built on them.
·9 min read · #dsa#hashing#intermediate