ACID Transactions Explained With Examples
Atomicity, consistency, isolation and durability are the guarantees a transaction provides. Learn each one and the isolation levels.
Writer · Nepal
Writes practical, hands-on guides on AI, programming, cybersecurity, and technology — tested, explained, and updated when the facts change.
Atomicity, consistency, isolation and durability are the guarantees a transaction provides. Learn each one and the isolation levels.
Agile is a set of values, Scrum is a framework with roles and ceremonies, and Kanban is a flow method. Learn how they relate.
Ansible configures servers over SSH with no agent. Learn the inventory, the playbook, the modules and why idempotence matters.
API keys, JWTs, OAuth and sessions each solve a different problem. Learn how they work, when to use each, and the common mistakes.
A good error response tells the client what went wrong and what to do. Learn the status codes, the body shape, and the validation errors.
Offset, cursor and keyset pagination each trade simplicity for correctness. Learn the trade-offs and which to choose for a large dataset.
URL, header and media-type versioning each break a client differently. Learn the trade-offs and how to make a change without a new version.
ARIA can make a widget accessible or make it worse. Learn the labels, the roles, the live regions and the first rule of ARIA.
A good question gets a fast answer. Learn the structure, the minimal reproduction, and the mistakes that make a question hard to answer.
Burnout is a pattern, not a personal failing. Learn the warning signs, the causes specific to software work, and the habits that help.
Move slow work out of the request. Learn the queue, the worker, the retry policy, idempotency and how to monitor a background job.
A shell script automates a sequence of commands. Learn the syntax, the quoting rules, and the error handling that prevents surprises.
Both are deliberately slow. Learn the parameters, the memory cost, and which password hash to choose for a new application.
Big-O notation describes how an algorithm's cost grows as input grows. Learn the common classes, how to read them, and the mistakes beginners make.
Binary is base 2 and hex is base 16. Learn the conversions, the bit operations, and why hex appears everywhere in programming.
Binary search finds a value in a sorted array by halving the search space each step. Learn the algorithm, the off-by-one traps, and real variants.
AND, OR, XOR, NOT and shifts work on individual bits. Learn the operators, the masks, and the real uses in application code.
Run two identical environments and switch traffic between them. Learn the setup, the database problem, and when it is worth it.
A portfolio project should show judgement, not just code. Learn what to build, what to document, and the mistakes that hide good work.
A cache trades freshness for speed. Learn the strategies, the invalidation problem, and the patterns that avoid a stampede.
A callback is a function passed to another function to be called later. Learn how they work, callback hell, and how to avoid its pitfalls.
Send a small share of traffic to the new version, watch the metrics, and roll forward or back. Learn the routing, the metrics and the traps.
A distributed system can have two of three. Learn what the theorem actually says, the common misreading, and the PACELC extension.
A character is not a byte. Learn Unicode, UTF-8, the mojibake bug, and how to fix the encoding problems that produce garbled text.
CI merges and tests often, CD ships automatically. Learn the pipeline stages, the difference between delivery and deployment, and the gates.
Continuous integration and delivery automate the path from commit to production. Learn the stages, the gates, and the pitfalls.
A closure is a function that remembers the variables where it was created. Learn how they work, the classic loop bug, and where they are useful.
Coverage shows which lines the tests execute, not whether they assert anything. Learn the metrics, the traps, and how to use it well.
Coverage measures which lines ran, not whether they were verified. Learn what it is good for, what it hides, and how to use it sensibly.
Reading code is most of the job. Learn how to navigate an unfamiliar repository, trace a request, and build a mental model fast.
Good code review catches bugs and shares knowledge without slowing the team down. Learn what to look for, what to skip, and how to give feedback.
Split a bundle so a page loads only the code it needs. Learn the route split, the dynamic import, and how to measure the result.
Contrast is a measurable accessibility requirement. Learn the ratios, the WCAG levels, and how to fix a failing colour without ruining it.
Inheritance models is-a relationships; composition models has-a. Learn why composition is more flexible, and when inheritance is still right.
A file is versioned and readable; an environment variable is injected and secret. Learn which setting belongs where, and why.
Opening a connection is expensive, so a pool reuses them. Learn the sizing, the exhaustion, the timeout, and the serverless trap.
A registry stores and distributes container images. Learn the tag, the digest, the layers, and the practices that keep a supply chain safe.
CSP restricts what a page may load, which blunts a cross-site scripting attack. Learn the directives, the nonce, and the report-only mode.
Find a project, find an issue, and get a pull request merged. Learn the etiquette, the workflow, and the mistakes that stall a contribution.
A commit message format that enables automation. Learn the types, the scope, the breaking change marker, and the tooling it unlocks.
Cookies carry state across requests. Learn the attributes, the SameSite values, the security flags, and the size and scope limits.
LCP, INP and CLS measure loading, interactivity and visual stability. Learn the thresholds, the causes, and how to improve each one.
CORS is a browser rule, not a server one. Learn the preflight, the headers, the credentials, and how to fix the common errors.
Inlining the above-the-fold CSS removes a render-blocking request. Learn how to extract it, inline it, and load the rest asynchronously.
Cron runs on a schedule and a queue runs on an event. Learn the difference, the overlap, and the pattern that combines them.
Cross-site request forgery makes a browser send an authenticated request. Learn the attack, the token defence, and SameSite cookies.
Learn anchor-name, position-anchor, and position-area with a small panel, then add a readable fallback and test narrow-screen behavior before shipping.
CSS animations run without JavaScript and perform well when you animate the right properties. Learn keyframes, timing, and accessibility.
Every element is a box of content, padding, border and margin. Learn how the box model works and why box-sizing changes everything.
Custom properties are live CSS variables with inheritance and cascade. Learn the syntax, theming patterns, and how they differ from preprocessor variables.
Flexbox lays out items along one axis. Learn the container and item properties, the common patterns, and the gotchas that trip people up.
CSS Grid lays out content in rows and columns at once. Learn the track syntax, named areas, auto-fit, and the patterns that replace old hacks.
Static, relative, absolute, fixed and sticky each position an element differently. Learn the containing block and the common traps.
Pseudo-classes select elements by state or position. Learn :hover, :focus-visible, :nth-child, :has, and the ones that matter most.
From a class to an attribute and a pseudo-class, learn the selectors you actually use and the ones that cause a specificity problem.
Specificity decides which CSS rule wins when several match. Learn the scoring, the cascade layers, and how to avoid specificity wars.
CSS transforms move, rotate, scale and skew elements without affecting layout. Learn the functions, the origin, 3D, and performance.
Absolute and relative units each have a place. Learn when to use px, rem, em, vh, vw, ch and the newer viewport units in CSS.
curl is the tool for talking to an HTTP API from the terminal. Learn the flags for a request, a header, a body, a file and a debug trace.
Implement dark mode with prefers-color-scheme and custom properties. Learn the contrast, the images, and the flash of the wrong theme.
A practical tour of the data structures you actually use: arrays, hash maps, sets, stacks, queues, trees, heaps and graphs, with real trade-offs.
An index trades write speed and space for read speed. Learn the B-tree, the composite index, the covering index and the query plan.
An index trades write speed and space for read speed. Learn how a B-tree works, when an index is used, and the common mistakes.
A migration changes a schema without losing data. Learn the safe patterns, the zero-downtime approach, and how to roll back.
Normalization removes redundancy and update anomalies. Learn the normal forms, the trade-offs, and when to denormalize deliberately.
Sharding splits a table across servers when one is not enough. Learn the shard key, the routing, the rebalancing and the cost.
Timezones, DST, leap seconds and floating clocks. Learn the rules, the storage format, and the bugs that appear twice a year.
Interviewers care about your process, not the answer. Learn the structure, the questions to ask, and the habits that signal competence.
Breakpoints let you pause a program and inspect its state. Learn conditional breakpoints, watch expressions, and how to debug without print statements.
Programming needs long uninterrupted blocks. Learn how to protect them, how to batch the shallow work, and how to measure the result.
Dependency inversion says high-level policy should not depend on low-level detail. Learn what that means in practice and why it makes code testable.
Most of your code is a dependency. Learn how to scan, how to triage, and how to fix a vulnerability without breaking the build.
Most of your code is dependencies. Learn how to scan them for known vulnerabilities, triage the results, and keep them patched.
Design patterns are named solutions to recurring problems. Learn the handful that appear constantly in real code, with examples and when to skip them.
A signature proves who sent a message and that it was not changed. Learn the keys, the hash, the verification and the common mistakes.
DNS resolves a name to an address through a chain of servers. Learn the record types, the caching, the TTL, and how to debug a lookup.
Docker packages an application with its dependencies. Learn images, containers, volumes, and the commands you actually use.
Compose defines a multi-container application in one file. Learn services, networks, volumes, and the commands you use daily.
An image is a template and a container is a running instance. Learn the layers, the writable layer, and why the distinction matters.
How containers talk to each other and to the outside world. Learn the network drivers, port publishing, and DNS by service name.
A container's filesystem is ephemeral. Learn how volumes, bind mounts and tmpfs differ and which one to use for what kind of data.
A good Dockerfile builds fast and produces a small image. Learn layer caching, multi-stage builds, and the common mistakes.
DRY, KISS and YAGNI are three heuristics for simpler code. Learn what each really means, how they conflict, and how to apply them sensibly.
Dynamic programming solves problems by caching overlapping subproblems. Learn memoisation, tabulation, and how to spot a DP problem in the wild.
Edge functions run in many locations near the user. Learn the model, the limits, the cold start and when a serverless function is better.
Encryption hides data, hashing verifies it, and a signature proves origin. Learn the three, the keys, and the mistakes to avoid.
End-to-end tests cover the critical user journeys. Learn the selectors, the flakiness fixes, and how to keep the suite small and reliable.
Environment variables configure an application without changing code. Learn the patterns, the security rules, and the traps.
Good error handling is a design decision, not a try/catch afterthought. Learn patterns for propagating, wrapping, and recovering from failures.
import/export or require/module.exports? Learn the differences, the interop rules, and how to migrate a project safely today.
Estimates are uncertain, not wrong. Learn the techniques, the biases, and how to communicate a range instead of a single date.
An ETag is a fingerprint of a response. Learn how a conditional request works, the weak and strong forms, and the common mistakes.
Attach one listener to a parent instead of hundreds to children. Learn the bubbling, the target, and the pitfalls to avoid.
JavaScript is single-threaded yet handles concurrency. Learn the call stack, task queues, microtasks, and why setTimeout has a minimum delay.
A distributed system cannot be instantly consistent everywhere. Learn the models, the read-your-writes problem, and the fixes.
Exceptions and error codes are two ways to signal failure. Learn the trade-offs, when each fits, and why most languages use both.
Factories create objects without exposing which class is instantiated. Learn simple factories, factory methods, and when they earn their keep.
Create a local FastAPI endpoint with a Pydantic request model, try valid and invalid JSON, and separate validation from storage and permissions.
A flag decouples a deploy from a release. Learn the types, the lifecycle, the debt, and how to avoid a flag that never dies.
fetch is the modern way to make an HTTP request in the browser. Learn the response handling, the errors, the abort, and the streaming.
A flaky test passes and fails without code changes. Learn the common causes, how to find them, and how to fix them properly.
Binary floating point cannot represent most decimals exactly. Learn the cause, the consequences, and how to handle money.
clamp() scales a font size with the viewport without a media query. Learn the formula, the accessibility limits, and the pitfalls.
A form is the most common interaction and the most common accessibility failure. Learn the labels, the errors, the focus and the ARIA.
Generics let you write one function or class that works with many types while keeping type safety. Learn the syntax, constraints, and common patterns.
Aliases and config settings remove friction from daily Git use. Learn the useful ones and how to set them up.
Bisect does a binary search through history to find the commit that introduced a bug. Learn the workflow and how to automate it.
Trunk-based, Git Flow, and GitHub Flow each suit different teams. Learn how they work, the trade-offs, and how to choose one.
Cherry-pick applies one commit to another branch. Learn the syntax, the conflicts, the ranges, and when a merge is better.
A commit message is documentation for the future. Learn the conventions, the structure, and the habits that make history useful.
Hooks run scripts at points in the Git workflow. Learn the useful ones, how to share them, and why Husky exists.
Git is bad at large binaries. Learn why, how Git LFS works, and how to clean a repository that already has them.
Merge preserves history, rebase rewrites it. Learn the difference, the golden rule, and how to choose for your workflow.
Stash shelves uncommitted changes so you can switch context. Learn the commands, the pitfalls, and when a commit is better.
A submodule is a repository inside a repository. Learn the commands, the detached HEAD, the alternatives, and the traps.
Submodules and subtrees both embed one repository in another. Learn how each works and which to choose.
Reset, revert, restore, and reflog. Learn which command undoes which situation, and how to recover from a mistake safely.
Worktrees let you check out multiple branches in separate directories from one repository. Learn when they beat stashing.
GitHub Actions runs your CI in the repository. Learn the workflow syntax, the job graph, caching, and the security rules that matter.
A .gitignore is a set of patterns, and the rules are subtle. Learn the syntax, the precedence, and the mistakes to avoid.
A .gitlab-ci.yml defines the pipeline. Learn the stages, the jobs, the artifacts, the cache and the rules that control them.
GraphQL lets the client ask for exactly what it needs. Learn the schema, the query, the resolver, and the N+1 problem in practice.
GraphQL and REST solve different problems. Learn the trade-offs, the costs GraphQL adds, and the cases where each is the better fit.
Search file contents with grep and the filesystem with find. Learn the flags that matter and how to combine them safely.
gRPC is a binary RPC framework over HTTP/2. Learn the protobuf schema, the four call types, and when REST is the better choice.
Hash tables turn keys into array indexes with a hash function. Learn how they work, how collisions are handled, and why lookups are O(1) on average.
A hash is one-way and an encryption is reversible. Learn the uses, the algorithms, and why a password is hashed not encrypted.
A higher-order function takes a function as an argument or returns one. Learn map, filter, reduce, and how to build your own abstractions.
A form is the main way a user gives you data. Learn the input types, the native validation, the labels, and the error handling.
Build a native HTML popover with a real button, test dismissal and keyboard behavior, and understand why a non-modal panel is not a modal dialog.
Semantic HTML describes meaning, not appearance. Learn the elements, the accessibility and SEO benefits, and the common mistakes to avoid.
Cache-Control, ETag and Vary decide what a browser and a CDN cache. Learn the directives, the revalidation, and the common mistakes.
HTTPS is HTTP inside TLS. Learn the handshake, the certificate, the mixed content problem, and why every site needs it today.
A retry can duplicate a payment. Learn the idempotency key, the storage, the race, and how the response is replayed.
Immutable data cannot be modified after creation. Learn how it prevents whole classes of bugs, how to update it efficiently, and when to skip it.
A postmortem turns an incident into a change. Learn the timeline, the root cause, the action items, and the blameless culture.
IndexedDB is a real database in the browser. Learn the object store, the index, the transaction, and the async API.
IaC describes infrastructure in a file. Learn the declarative model, the state, the plan, and the drift problem.
Validate at the boundary, allowlist what is expected, and never trust the client. A practical guide to validating input safely.
Unit tests isolate one piece; integration tests verify pieces work together. Learn the trade-offs and how to balance the two.
Interfaces define a contract; abstract classes share implementation. Learn the difference, the trade-offs, and how to choose in real designs.
An IP address identifies a host on a network. Learn IPv4, IPv6, the subnet mask, CIDR notation, and the private ranges.
map, filter, reduce and friends are the core of modern JavaScript. Learn what each does, when to use it, and the mistakes to avoid.
A bundler resolves imports, transforms code and writes a file the browser can load. Learn the graph, the loaders, and the output.
The Date object has real pitfalls: timezones, month indexing, and parsing. Learn the traps and the modern alternatives.
The console has more than log. Learn table, group, time, trace, and the DevTools features that make debugging faster.
Destructuring pulls values out of arrays and objects into variables. Learn the syntax, defaults, renaming, and the nested patterns.
The DOM is the page as a tree. Learn the selection, the creation, the update, the events, and the performance traps.
Map and Set are keyed collections with real advantages over objects and arrays. Learn the API, the differences, and when they win.
Modules split code into files with explicit dependencies. Learn ESM syntax, the CommonJS differences, and the interop gotchas.
Object.keys, entries, assign, freeze and the rest. Learn what each does, the shallow-copy trap, and the modern alternatives.
?. and ?? make null-safe access readable. Learn the syntax, the difference from ||, and the cases where they hide bugs.
Most JavaScript is fast enough. Learn where the real bottlenecks are, how to measure, and the optimisations that actually matter.
Regex is powerful and easy to get wrong. Learn the syntax, the flags, the common patterns, and how to test them safely.
Spread expands an iterable into individual elements. Learn the copy, merge, and call patterns, plus the shallow-copy trap.
jq filters, transforms and formats JSON in a shell pipeline. Learn the filters, the operators, and the patterns you will use daily.
A JSON Schema describes the shape of a JSON document. Learn the types, the constraints, the composition, and the validation.
A JWT is three base64url parts joined by dots. Learn how signing works, what it proves, and the mistakes that make tokens insecure.
Kubernetes orchestrates containers across machines. Learn the core objects, the mental model, and when you do not need it.
loading=lazy defers an offscreen image. Learn the attribute, the LCP trap, the placeholder, and the sizes attribute.
Linked lists store elements in nodes connected by pointers. Learn singly and doubly linked lists, their real costs, and when they actually beat arrays.
The shell commands you use every day: navigation, files, search, pipes, permissions, and the habits that make the terminal fast.
Read, write, execute for owner, group and others. Learn the octal notation, the special bits, and how umask sets defaults.
Find a process, read its state, and stop it cleanly. Learn the process tree, the signals, and the tools that show what is running.
A load balancer spreads traffic across backends. Learn the algorithms, the health check, the session affinity, and the layer.
A load test finds the point where a system degrades. Learn the metrics, the test types, and how to run one without breaking production.
Three browser stores, three lifetimes. Learn the scope, the size, the security, and which one fits a given value.
Good logs make incidents short and bad logs make them long. Learn log levels, structured logging, what to log, and what never to log.
A log level is a severity. Learn the levels, the structured log, the correlation id, and what must never be logged.
Long polling holds a request open until there is data. Learn the mechanism, the timeout, the reconnect, and the alternatives.
Make is a build tool that runs a command when a file is out of date. Learn the rules, the variables, and the patterns worth knowing.
A queue decouples a producer from a consumer. Learn the delivery guarantee, the dead letter, the ordering, and the backpressure.
Observability rests on three signals. Learn what each answers, the cardinality, the sampling, and how they combine.
Mobile-first means the base styles target small screens and larger screens add complexity. Learn the approach, the benefits, and the pitfalls.
Mocks, stubs, fakes and spies are different test doubles. Learn what each is for, when to use them, and why over-mocking makes tests brittle.
MongoDB stores a document, not a row. Learn the collection, the query, the index, the aggregation, and the schema design.
Monitoring checks a known signal, and observability answers a new question. Learn the SLI, the alert, and the cardinality.
One repository or many? Learn the trade-offs, the tooling each layout needs, and the signals that point to the right choice.
One query becomes N+1. Learn how it happens, how to detect it, and the eager loading, batching and join fixes.
Good names make code readable without comments. Learn the conventions for variables, functions, classes and files, and the habits that produce them.
Nginx serves static files and proxies requests. Learn the config structure, the common blocks, and the patterns you need.
The three Node package managers differ in speed, disk usage and strictness. Learn the trade-offs and how to choose for a project.
Null, undefined, nil, None and NaN all represent absence, but they differ. Learn the distinctions and how to handle missing values safely.
OAuth 2.0 lets an app access a user's data without their password. Learn the flows, the tokens, and the mistakes that cause vulnerabilities.
The observer pattern lets objects subscribe to changes in another object. Learn how it works, how to avoid leaks, and where it appears in real code.
An ORM trades control for convenience. Learn the trade-offs, the N+1 trap, and the hybrid approach most teams settle on.
The OWASP Top 10 lists the most critical web risks. Learn each one, the cause, and the concrete fix for it.
The manifest of a Node project. Learn the fields that affect resolution, the scripts, the exports map, and the version ranges.
A password must be hashed with a slow algorithm. Learn Argon2id, bcrypt, the cost, the salt, and the migration path.
Passwords must be hashed with a slow, salted algorithm. Learn why bcrypt, scrypt and Argon2 are the right choices and what to avoid.
A pen test finds a flaw before an attacker does. Learn the scope, the rules of engagement, the phases, and the report.
Use Playwright role and label locators, understand strict matches and auto-waiting, and test a small form without fixed sleeps or fragile selectors.
Postgres is a relational database with a rich feature set. Learn the query, the index, the transaction, and the JSON support.
A PWA is a web app that installs and works offline. Learn the manifest, the service worker, the cache, and the install prompt.
Promises and async/await solve the same problem in different styles. Learn how each works, the pitfalls of both, and how to choose.
Property-based tests assert invariants that hold for all inputs, and the framework generates the cases. Learn how it finds bugs example tests miss.
Publish-subscribe decouples a producer from many consumers. Learn the topic, the fan-out, the delivery, and the ordering.
A key pair has a public and a private half. Learn the encryption, the signature, the key exchange, and the trust problem.
A pure function returns the same output for the same input and changes nothing outside itself. Learn why that matters and how to manage side effects.
Build a small Pydantic model, validate JSON, handle clear errors, and understand coercion before trusting data from forms, APIs, or AI tools.
Learn pytest parametrization with readable cases, boundary checks, and clear failures. Build a small test table without hiding the behavior being tested.
A rate limit protects a service from abuse. Learn the algorithms, the headers, the distributed case, and the client behaviour.
Rate limiting rejects excess requests; throttling slows them down. Learn the difference, the algorithms, and how to respond well.
A stack trace tells you exactly where a program failed and how it got there. Learn to read one top to bottom and find the cause fast.
Refactoring changes code structure without changing behaviour. Learn the core techniques, how to stay safe, and when to refactor.
Regression tests guard against old bugs returning. Learn how to write them, what to cover, and how to keep the suite from growing forever.
Breakpoints should follow your content, not device names. Learn how to choose them, the mobile-first approach, and modern alternatives.
A well-designed REST API is predictable and hard to break. Learn resources, methods, status codes, versioning, and pagination.
Explaining your code out loud often reveals the bug before you finish. Learn why it works and how to use it deliberately.
Learn Ruff with a small Python project: find unused imports, preview fixes, format code, and add read-only checks without hiding useful warnings.
Secrets in code and config files leak. Learn where to store them, how to inject them, and how to rotate them without downtime.
HSTS, CSP, X-Content-Type-Options and the rest. Learn what each security header does and how to set it without breaking your site.
Server sessions and stateless tokens solve the same problem differently. Learn the trade-offs and which fits your application.
Singleton guarantees one instance of a class. Learn how it works, why it is often criticised, and the better alternatives in modern code.
SOLID is five design principles for maintainable object-oriented code. Learn each one with concrete examples of the problem it prevents.
Compare bubble, insertion, merge, quick, heap and counting sort on time, space and stability, and learn which one your language actually uses.
SQL injection happens when user input becomes SQL code. Learn how it works and why parameterised queries are the definitive fix.
Inner, left, right, full and cross joins each return a different set of rows. Learn the difference and the mistakes that cause duplicates.
Relational and non-relational databases make different trade-offs. Learn the categories, the guarantees, and how to choose.
SSH keys authenticate you without a password. Learn how to generate them, configure hosts, and debug a connection that fails.
Stacks are last-in-first-out and queues are first-in-first-out. Learn how both work, how to implement them, and where each appears in real software.
Static analysis finds a bug before the code runs. Learn the categories, the tools, and how to add them to a pipeline without friction.
Static typing checks types before running; dynamic typing checks at runtime. Compare the trade-offs with real examples and pick the right tool.
The strategy pattern swaps algorithms at runtime behind a common interface. Learn how it works, when it beats conditionals, and its trade-offs.
Test data is the hidden cost of a test suite. Learn factories, fixtures, seeding, and how to keep tests independent and fast.
TDD is a short red-green-refactor cycle that shapes design as much as it verifies code. Learn the loop, the benefits, and the common objections.
Almost every performance decision trades time for memory. Learn how to reason about the trade-off, when each side wins, and how to measure it.
Trees model hierarchy and graphs model relationships. Learn the structures, the traversal algorithms, and where each appears in real software.
The twelve factors describe how to build a service that deploys cleanly. Learn each factor and what it means in practice.
A type system is a set of rules for classifying values and checking how they combine. Learn static vs dynamic, strong vs weak, and why it matters.
Learn when TypeScript satisfies helps a configuration object, how it differs from an annotation or assertion, and why runtime data still needs validation.
Unit tests verify one piece of behaviour in isolation. Learn what makes a good test, the arrange-act-assert structure, and common mistakes.
Set up Vitest in a practice JavaScript project, test normal and boundary cases, read a deliberate failure, and run a one-shot check before committing.
Polling, long polling, SSE and WebSockets each fit a different real-time need. Learn how each works and which to choose.
Comments explain why, not what. Learn which comments earn their place, which are noise, and how to write ones that stay accurate.
Clean functions do one thing, have clear names, and few parameters. Learn the rules, the trade-offs, and how to refactor messy functions.
Cross-site scripting runs attacker code in your users' browsers. Learn the three types and the defences that actually stop them.
Use a small Zod schema to validate unknown data, handle success and failure without exceptions, and infer TypeScript types from the same definition.
How the five cron fields work, how to read any schedule at a glance, the day-of-month trap, timezone behaviour, and why cron silently fails.
How environment variables work across shells and platforms, why .env files leak secrets, and the configuration rules that keep deployments predictable.
Every HTTP status code that matters in practice, which one your API should actually return, and the mistakes that cause confusing client and server bugs.
What MAJOR.MINOR.PATCH actually promises, when a breaking change has to bump the major version, and why caret and tilde ranges behave the way they do.
How recursion actually works, when it beats a loop, how the call stack behaves, and the mistakes that turn a simple function into a crash.
A README is a product decision, not documentation duty. The structure that works, what to cut, and the ten-minute test that tells you if yours is broken.
AI coding agents have moved beyond chatbots to autonomous coding. Learn how agentic coding works, what it can and cannot do, and how to use it safely in production.
Static hosting comparison: Cloudflare Pages, GitHub Pages, Vercel, and Netlify free tiers—features, limits, and what to check before choosing.
Containers and virtual machines both isolate apps, but they work differently. See the difference, trade-offs, and when to use each.
A complete guide to Free Fire (Garena Free Fire) in 2026: gameplay, characters, weapons, maps, game modes, ranking system, tips, and everything you need to dominate the battlefield.
Learn the Git commands you actually use every day: init, add, commit, push, pull, branch, merge, stash and how to undo mistakes safely.
Compare JSON, YAML and TOML for config files and data: syntax, comments, readability and the mistakes to watch for. Same data in all three.
Model Context Protocol vs traditional APIs: when to use MCP, when to stick with REST APIs, and how to choose the right integration pattern for AI-powered applications.
Run a language model offline on your own PC with Ollama. Install steps, hardware basics, your first chat, and how to call it from code.
Linux phones home more than you think. Per-app firewall rules with Portmaster, hardened DNS, and Brave settings that cut trackers without breaking sites.
A blueprint for reimagining education - mastery learning, real-world projects, AI as collaborator, and a roadmap for Nepal.
Go is used by 16.4% and Rust by 14.8% of developers in 2026. Performance, concurrency, jobs, and learning curve compared so you can choose with confidence.
Jellyfin plus Docker Compose gives you a private Netflix in an hour. Install, hardware transcoding, libraries, reverse proxy, and backups step by step.
Who sells the most smartphones in 2026? Market share data from Counterpoint and IDC, plus brand profiles of Samsung, Apple, Xiaomi, OPPO, vivo, Huawei, Honor, and more.
uv rewrote Python packaging in Rust with 10-100x faster installs, unified venvs, lockfiles, and script running. Setup, commands, and migration from pip and Poetry.
Vibe coding builds apps by prompting AI agents. The workflow that actually ships: specs, guardrails, context hygiene, testing, and knowing when to graduate.
Open-weight versus open-source, the OSI's AI definition, why major models fail it, and what developers should actually check before building on an 'open' model.
Build and publish Node.js command-line tools: shebang, package.json bin, commander.js arguments, colored output, prompts, testing, and npm publishing.
First-person account of rebuilding a portfolio site with Astro: what survived, what got cut, performance targets, and lessons from shipping a static site.
Neobanks spent a decade proving that a better app is not a bank. Now that the survivors are profitable, the actual lessons are clearer — and fewer than the pitch decks claimed.
How to turn a side project into income that actually replaces a job — validation, pricing, time management, and the unglamorous middle stretch most people quit.
Practical game accessibility: remapping that works, captions, contrast, difficulty options, photosensitivity, and the guidelines worth building against.
Practical guide to building and running a remote team at a small company — hiring, async communication, trust, onboarding, and the metrics that actually matter.
Nepal went from cheque-heavy retail payments to over a trillion rupees a month on real-time rails in a few years. How the shared-infrastructure model worked, and what is left to solve.
Why individual sensors fail differently, and how complementary, Kalman, and gradient-descent filters combine them — with code, tuning, and calibration details.
Most productivity systems work until life happens. How to design personal and team systems with degraded modes, re-entry rituals, and slack so a bad week does not erase everything.
Explaining a concept in plain language exposes exactly what you do not understand — how the technique works, where the four steps came from, and how to run it well.
Design tokens as a shared source of truth: the W3C DTCG format, primitive/semantic/component layers, theming, build pipelines, and how to migrate off hex values.
Microplastics are in human blood, lungs, placentas, and brains. Here is what the measurement science shows, what early health studies suggest, and where the evidence runs out.
When to validate, what to say, and how to wire errors for screen readers — blur-based checks, reward-early-punish-late, and accessible error states.
First-person hardware case study: breadboard to PCB, component sourcing, enclosure, manufacturing, certifications, and the mistakes that cost time and money.
You are the SOC, the on-call engineer, and the communications team. A practical incident response playbook for developers who work alone.
A practical walkthrough of shipping an Android app on Google Play — signing, Play Console setup, target API levels, Data safety, and the review process.
An evergreen guide to the tech regulations shaping developer work — the EU AI Act timeline, adjacent digital rules, and how compliance actually shows up in engineering practice.
Most commercial software depends on unpaid maintainers. Here is how the funding gap happened, what AI-generated noise made worse, and which models are actually working.
Add rate limiting to a Node.js REST API with Express: per-route limits, Redis stores, proxy headers, 429 responses, and real commands you can run.
How freelancing from Nepal actually works in 2026: payment routes that function, tax and banking compliance, pricing, and the operational habits that keep income durable.
Not all digital wallets store money the same way. A comparison of custodial, bank-linked, tokenized card, and self-custody models — and what each means for fraud, recovery, and privacy.
How to write shell scripts that survive real use — strict mode, quoting, dry runs, ShellCheck, and knowing when a script should have been a program.
A practical framework for evaluating LLM outputs: golden sets, programmatic checks, LLM-as-judge with rubrics, agreement metrics, and evals in CI.
How multiplayer games hide latency: prediction, reconciliation, interpolation, lag compensation, lockstep, and rollback — and which model fits which genre.
How to do affiliate marketing honestly — disclosure, choosing products you actually use, realistic conversion rates, and building trust instead of churning review spam.
How to write a lean business plan that helps you make decisions — not a 40-page document nobody reads. Focus on assumptions, unit economics, and milestones.
A practical, no-hype workflow for using AI coding tools to write better code — where it helps, where it hurts, and the habits that make it worth it.
Microinteractions are the small feedback loops that make an interface feel responsive: triggers, states, timing, and the CSS that makes them cheap.
Why managing attention and energy beats optimizing the clock — chronotypes, ultradian rhythms, cognitive load, and a practical system for matching tasks to capacity.
Print settings and material choices for parts that must bear load, survive heat, and last — layer adhesion, anisotropy, infill, annealing, inserts, and tolerances.
Technical debt in practice: what counts as debt, how to translate it into delivery risk non-engineers understand, and how to pay it down without a rewrite.
How to turn scattered notes into a system you actually retrieve from — atomic notes, links versus folders, a workable workflow, tools, and common anti-patterns.
First-person guide to open source beyond the repository: licenses, README, governance, security policy, maintainer burnout, and sustainability.
Six failure types account for 96% of detected accessibility errors — contrast, alt text, labels, empty links and buttons, and document language.
Why physicists are confident something invisible is out there — rotation curves, lensing, the CMB — and why nobody knows what it actually is.
Reading code is a separate skill from writing it. A practical method for understanding unfamiliar codebases fast, from someone who had to learn it the hard way.
Async-first collaboration, AI-augmented meetings, and lean tool stacks — an analysis of how distributed teams actually work now and what the durable tool categories are.
On-demand, spot, reserved instances, savings plans, and egress fees — how each pricing model works, what it costs you in flexibility, and when to use which.
Mobile broadband dominates Nepal, FTTH is growing fast, and the real gaps are rural, backhaul, and last-mile reliability. A grounded look at the country's internet infrastructure in 2026.
How to test Jetpack Compose screens that do not flake — semantics, state hoisting, synchronization with the v2 test APIs, and where screenshot tests fit.
Encryption at rest protects stored data from disk theft and provider access. Encryption in transit protects moving data from network interception. Both matter, differently.
Most blockchain projects fail because a database would do. A clear-eyed look at the use cases where shared ledgers actually earn their keep — and the ones that never will.
A complete step-by-step home lab build: choose hardware, install Debian, harden SSH, set up storage and backups, run containers, and reach it remotely.
A context window is how much text fits, not how much the model uses. How positional bias, context rot, and cost make effective context smaller than advertised.
Ghostty, Kitty, Alacritty, WezTerm, foot, and Windows Terminal compared — features, benchmarks, and how to choose without chasing benchmarks.
Passkeys replace passwords with cryptographic keys. Here is how they actually work, why they are more secure, and how to start using them today.
An honest look at bootstrapping versus venture funding — ownership, growth speed, survival rates, and how to choose based on your actual business, not ideology.
What content creators actually earn from blogs, YouTube, and newsletters — real RPM data, realistic timelines, and why diversification beats ad revenue alone.
How to build a color system that scales: perceptual color spaces, ten-step ramps, semantic tokens, contrast pairing, and the checks that catch failures early.
How to pick an MCU for an IoT build — radio first, then a real power budget, memory, toolchain, and certification — with sleep-current comparisons and worked battery math.
A zero-budget marketing plan for indie games: store page craft, short-form video, wishlists, festivals, and outreach that actually gets answered.
A hypothesis-driven approach to debugging: reproduce reliably, localize with bisection, instrument with intent, fix root causes, and prevent recurrence.
Sleep stages, the two-process model, memory consolidation, and the claims that survive scrutiny — an evidence-based look at what sleep does and what we still do not know.
Where AI agents genuinely work in 2026, the measured limits of long-horizon tasks, why reliability lags capability, and how to deploy them safely.
A practical digital minimalism approach for developers — notification audits, tool diet, Slack hygiene, RSS, and keeping the web useful without drowning in it.
Static generation and SSR compared on cost, caching, freshness, failure modes, and personalization — plus a decision framework and migration path.
Retrieval practice beats rereading in the research — what active recall is, why it works, the effect sizes, and how to use it across subjects without wasting time.
Anycast, BGP, cache hierarchies, and cache keys — the actual machinery behind content delivery networks, explained without the marketing layer.
How WorkManager actually schedules work — constraints, unique work, chains, expedited jobs, and the failure modes that show up in production apps.
First-person account of shipping a first mobile app: framework choice, app store rejections, review times, crashes, updates, and what I would do differently.
Quishing, adversary-in-the-middle kits, AI-written lures, and ClickFix scams have changed phishing. Here is what works in 2026 and how to defend against it.
A practical guide to building a useful home lab in Nepal without imported gear or a big budget - hardware, power, internet, and what to actually run.
A founder-level look at building a startup in Nepal: what actually blocks growth, where the real opportunities are, and how teams are getting past both.
Deploy a real multi-service app with Docker Compose - compose.yaml structure, healthchecks, env files, volumes, updates, reverse proxy, and backups on a single server.
Make, Just, and go-task compared on syntax, dependencies, arguments, and cross-platform support — with the same project implemented three ways.
An evergreen analysis of the web framework landscape — React's plateau, Astro and Svelte's rise, the Vite toolchain shift, and how AI-assisted coding is reshaping framework choice.
Banking APIs turned bank data into something third parties can use with consent. How open banking and open finance work, where the standards are, and what actually builds on top.
Practical naming rules for code: how to name variables, functions, and files so readers get context at the point of use without reading the body.
Practical pricing strategies for freelancers and small businesses — value-based pricing, package pricing, retainer models, and how to stop leaving money on the table.
A practical survey of procedural generation: noise, BSP, cellular automata, wave function collapse, grammars, and how to keep control of the output.
Same-document and cross-document view transitions explained — startViewTransition, view-transition-name, the @view-transition rule, and accessibility.
Dark mode is a separate theme, not a color inversion. Surface elevation, desaturated accents, halation, media handling, and the CSS to ship it.
A practical decision guide comparing fine-tuning and prompting for LLM tasks — what each actually changes, cost tradeoffs, and a checklist for choosing.
What the three terms of a PID controller actually do, how each one changes the response, how to tune them with Ziegler-Nichols, and the failures you will meet first.
Baseline, Interop, and a wave of new CSS and HTML features have changed what you can ship without polyfills. A clear look at where the platform stands in 2026.
A realistic guide to building and selling digital products — courses, templates, ebooks, and tools. What sells, what it costs, and why margins are high but discovery is hard.
Practical patterns for Android Room — reactive Flow queries, relations, transactions, migrations, and testing — that hold up when the app grows past a toy project.
The real mechanism behind CRISPR gene editing — guide RNA, PAM sequences, double-strand breaks, and the repair pathways that decide the outcome.
A frank look at popular productivity rules — the two-minute rule, Inbox Zero, Eat the Frog, Pomodoro — what each gets right, where each breaks, and what to keep.
A practical guide to diagnosing slow test suites: startup costs, database fixtures, sleeps, e2e scope, parallelism, and the budgets that keep suites fast.
Why following tutorials stops teaching you anything, and a concrete path out — from imitation to modification to building your own projects, with rules and a project ladder.
Build a dotfiles repository you can apply to any machine in minutes — repo layout, Stow vs chezmoi vs yadm, bootstrap scripts, and keeping secrets out of git.
First-person case study of building a URL shortener: stack choices, code generation, database schema, open redirect bug, rate limiting, and the mistakes that mattered.
Retrieval-augmented generation explained end to end: chunking, embeddings, hybrid search, reranking, failure modes, and how to evaluate whether your RAG system works.
A hands-on Astro 6 walkthrough: scaffold the project, define a typed content collection, render posts, add pagination and RSS, then build and deploy a static blog.
A practical, step-by-step audit of every account, data broker, and exposure you have online. Includes tools, a repeatable checklist, and what to cut first.
Nepal's tech sector in 2026: a billion-dollar services export base, real fintech infrastructure, and a startup scene fighting capital gaps, policy friction, and the missing middle.
Custom silicon, inference economics, and portable kernels — an analysis of the AI accelerator landscape and what working developers should actually do about it.
Edge computing moves code closer to users. It wins for latency-sensitive request paths and loses for heavy compute, state, and anything needing a region.
UPI turned India into the world's largest real-time payment system. A clear look at its design, scale, economics, and how its model spread across South Asia.
A practical guide to Compose layouts — when ConstraintLayout is worth using, how its DSL works, and the layout patterns that replace nested Row and Column trees.
A practical guide to getting your first 10 paying customers — cold outreach, warm networks, communities, and why these early customers matter more than scale.
Dependency injection is a practice, not a container. How constructor injection, composition roots, and manual wiring give you the benefits without the indirection.
Inside a rigid body physics engine: broad phase, narrow phase, integration, sequential impulse solving, position correction, fixed timesteps, and tuning.
Container queries let components respond to their parent instead of the viewport — setup, size vs inline-size, query units, and migration strategy.
A working guide to web typography for developers: type scales, line length, line height, font loading, variable fonts, and CSS that keeps text readable.
A practical walkthrough of PCB design — schematic capture, footprints, ground planes, trace widths, DRC, Gerbers, and bringing up your first board without surprises.
How to set freelancing rates that pay the bills and reflect your skill — market benchmarks, hourly vs project vs value pricing, and how to raise without losing clients.
Ripgrep, fd, bat, fzf, zoxide, delta and the rest of the modern CLI toolkit — what each replaces, real commands, and how to adopt them without breaking scripts.
How forgetting actually works, what the spacing research shows, and how to build a review system — intervals, card design, workload arithmetic, and limits.
Zero trust is not a product you buy. It is a set of access decisions you make per request. Here is how small teams can implement it without a security department.
How to implement time blocking without turning your calendar into a fiction novel — block sizing, buffer design, meeting weeks, and what the research actually says about it.
What quantum computers actually do, why they are not faster computers, and where the field really stands — qubits, error correction, and honest timelines.