Writing archive

Blog page 4

Older notes, lessons, and series entries from the growing technical library.

Posts page 4

Showing 145-192 of 1,446

Jul 17, 20266 min readSeries: Tech Explained Simply · Part 162

Infrastructure as a Service: Renting Foundational Cloud Resources

Learn what Infrastructure as a Service provides, what customers still manage, and how virtual machines, networks, storage, patching, access, and resilience fit together.

#technology#cloud#iaas#virtual-machines

Jul 17, 20265 min readSeries: Tech Explained Simply · Part 161

Cloud Regions and Availability Zones: Designing for Location and Failure

Learn how cloud regions and availability zones organize infrastructure, which failures each boundary addresses, and how latency, data residency, and cost shape deployment.

#technology#cloud#regions#availability-zones

Jul 17, 20267 min readSeries: Tech Explained Simply · Part 160

CAP as a Failure Trade-Off

Learn what the CAP theorem actually says about consistency and availability during network partitions, why partition tolerance is not an optional feature, and how choices differ by operation.

#technology#distributed-systems#cap-theorem#consistency

Jul 17, 20267 min readSeries: Tech Explained Simply · Part 159

Distributed Transactions and Sagas: Coordinating Work Across Services

Learn why one database transaction cannot easily span independent services, how two-phase commit differs from sagas, and how compensating actions manage partial workflow failure.

#technology#distributed-systems#sagas#transactions

Jul 17, 20266 min readSeries: Tech Explained Simply · Part 158

Eventual Consistency: Temporary Disagreement with a Convergence Promise

Learn why replicas and derived views can temporarily disagree, what eventual consistency does and does not guarantee, and how products handle stale reads and convergence.

#technology#distributed-systems#eventual-consistency#data

Jul 17, 20266 min readSeries: Tech Explained Simply · Part 157

Publish-Subscribe Systems: Sharing Events with Many Consumers

Learn how publish-subscribe systems distribute events to independent subscribers, how topics and subscriptions differ from queues, and why event contracts and replay matter.

#technology#distributed-systems#publish-subscribe#events

Jul 17, 20266 min readSeries: Tech Explained Simply · Part 156

Message Queues: Buffering Work Between Producers and Consumers

Learn how message queues decouple producers and workers, absorb bursts, support retries, and require explicit handling for duplicates, ordering, poison messages, and backlog.

#technology#distributed-systems#message-queues#asynchronous-processing

Jul 17, 20266 min readSeries: Tech Explained Simply · Part 155

Synchronous and Asynchronous Work: When Must the Caller Wait?

Learn how synchronous and asynchronous workflows differ, when background processing improves responsiveness, and what status, durability, retries, and cancellation async work requires.

#technology#distributed-systems#asynchronous-processing#architecture

Jul 17, 20266 min readSeries: Tech Explained Simply · Part 154

Idempotency: Making Repeated Requests Safer

Learn how idempotent operations prevent duplicate consequences, how idempotency keys work, and what storage, scope, concurrency, and response rules servers need.

#technology#distributed-systems#idempotency#apis

Jul 17, 20267 min readSeries: Tech Explained Simply · Part 153

Retries and Backoff: Repeating Work Without Making Failure Worse

Learn when retries recover transient failures, why immediate repetition can amplify outages, and how limits, exponential backoff, jitter, and idempotency make retries safer.

#technology#distributed-systems#retries#reliability

Jul 17, 20267 min readSeries: Tech Explained Simply · Part 152

Network Timeouts: How Long Should a Service Wait?

Learn why every remote call needs a timeout, how connection and response deadlines differ, and how to choose limits without confusing timeout with cancellation.

#technology#distributed-systems#timeouts#reliability

Jul 17, 202611 min readSeries: Quant Engineering · Part 2

The Minute-Bar Ledger: What a NIFTY Options Backtest Actually Reads

Spot, futures, and options are three different datasets with three different coverage windows — inventory them before writing a line of strategy code, or the engine will lie to you politely.

#quant#backtesting#market-data#nifty#parquet

Jul 17, 202611 min readSeries: Quant Engineering · Part 1

Quant Engineering: The Series Map

Why NIFTY options backtesting deserves an engineering series of its own, the two real engine builds behind it, and the map of the 1,100+ posts this library is growing into.

#quant#backtesting#options#nifty#series-map

Jul 17, 20265 min readSeries: AWS from Zero · Part 1126

AWS CLI configuration from zero: purpose, boundaries, and first CLI inventory

Build an accurate mental model of AWS CLI configuration, identify its control and data planes, and run a read-only discovery command.

#aws#cli#cli-foundations#configure#service-orientation

Jul 17, 20262 min readSeries: AWS from Zero · Part 1125

Cost Explorer: Provide anomaly feedback from the CLI

Use the AWS CLI to provide anomaly feedback in Cost Explorer, identify required inputs, and inspect the modeled response.

#aws#cli#cost-explorer#finops#cost

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 151

Distributed Systems: When One Application Spans Computers

Learn how networks, partial failure, concurrency, clocks, and imperfect knowledge change software when components run across multiple computers.

#technology#distributed-systems#networks#reliability

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 150

Quality as a Team System

Learn how software quality emerges from product decisions, design, implementation, review, testing, deployment, operations, and feedback across the whole team.

#technology#software-quality#teamwork#engineering

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 149

Static Analysis and Linters: Finding Problems Before Execution

Learn how static tools inspect code and artifacts for type errors, unsafe flows, suspicious patterns, and style violations without running the program.

#technology#static-analysis#linters#software-quality

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 148

Usability Testing: Watching People Use the Product

Learn how usability testing observes representative people performing realistic tasks to reveal confusion, hidden assumptions, and workflow friction.

#technology#usability-testing#user-experience#quality

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 147

Performance Testing: Workloads, Targets, and Bottlenecks

Learn how performance tests measure latency, throughput, resource use, and failure under realistic workloads, and why results need explicit targets and environments.

#technology#performance-testing#load-testing#quality

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 146

Regression Testing: Keeping Fixed Behavior Fixed

Learn how regression tests preserve corrected behavior, why a test should reproduce a bug before its fix, and how suites evolve with software risk.

#technology#regression-testing#software-testing#quality

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 145

Test Doubles and Mocks: Controlled Boundaries

Learn why tests replace dependencies, how fakes, stubs, spies, and mocks differ, and how excessive mocking can prove implementation details instead of behavior.

#technology#test-doubles#mocks#software-testing

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 144

End-to-End Tests: Protecting Critical User Journeys

Learn how end-to-end tests exercise realistic workflows through external interfaces, what broad confidence they provide, and how to reduce their cost and flakiness.

#technology#end-to-end-testing#software-testing#quality

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 143

Integration Tests: Verifying Real Boundaries

Learn how integration tests exercise databases, files, queues, frameworks, and service contracts to find mismatched assumptions between components.

#technology#integration-tests#software-testing#quality

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 142

Unit Tests: Fast Feedback on Focused Logic

Learn what unit tests isolate, where they provide strong evidence, how to structure them, and why testing implementation details creates brittle suites.

#technology#unit-tests#software-testing#quality

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 141

Why Software Testing Exists: Evidence, Not Certainty

Learn what software tests can prove, why exhaustive testing is usually impossible, how teams select risks, and how testing supports confident change.

#technology#software-testing#quality#engineering

Jul 16, 20268 min readSeries: Tech Explained Simply · Part 140

Documentation That Stays Useful

Learn what technical knowledge deserves documentation, how to place it near its users, assign ownership, verify procedures, and prevent important guidance from becoming stale.

#technology#documentation#runbooks#developer-workflow

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 139

Feature Flags: Separating Deployment from Release

Learn how feature flags control runtime behavior, support gradual rollout and experiments, enable quick disablement, and create lifecycle and testing responsibilities.

#technology#feature-flags#deployment#release

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 138

Development, Test, and Production Environments

Learn why teams separate development, test, staging, and production environments, how configuration and data differ, and how to prevent environment drift.

#technology#environments#deployment#developer-workflow

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 137

Build Tools: Turning Source into an Artifact

Learn how build tools compile, transform, bundle, validate, and package source code into reproducible artifacts that can be tested and deployed.

#technology#build-tools#compilation#developer-workflow

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 136

Semantic Versioning: Communicating Compatibility

Learn what major, minor, and patch versions communicate, how compatibility promises work, and where semantic versioning needs judgment rather than arithmetic.

#technology#semantic-versioning#dependencies#compatibility

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 135

Package Managers and Dependencies: Reusing Software Responsibly

Learn how package managers resolve and install dependencies, why manifests and lockfiles matter, and how teams manage compatibility, security, and supply-chain risk.

#technology#package-managers#dependencies#software-supply-chain

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 134

Code Review: Collaborative Risk Reduction

Learn how code review checks correctness, security, clarity, maintainability, and system fit while spreading knowledge and improving engineering decisions.

#technology#code-review#software-quality#collaboration

Jul 16, 20266 min readSeries: Tech Explained Simply · Part 133

Branches and Merging: Parallel Lines of Work

Learn how Git branches point to commit histories, how merging integrates work, why conflicts happen, and how teams keep parallel development manageable.

#technology#git#branches#merging

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 132

Git Commits: Meaningful Units of Software History

Learn what a Git commit contains, how staging shapes it, why focused commits improve review and recovery, and how to write history that remains understandable.

#technology#git#commits#developer-workflow

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 131

Version Control: A Shared History of Change

Learn how version control records snapshots, connects changes into history, supports collaboration, enables recovery, and gives software teams a dependable way to coordinate work.

#technology#version-control#git#developer-workflow

Jul 16, 20268 min readSeries: Tech Explained Simply · Part 130

User Experience and Feedback: Making System State Understandable

Learn how immediate feedback, loading, progress, disabled states, optimistic actions, confirmation, errors, recovery, undo, empty states, latency, notifications, accessibility, and trust make software understandable.

#technology#user-experience#feedback#interaction-design

Jul 16, 20268 min readSeries: Tech Explained Simply · Part 129

Application State Management: Ownership, Transitions, and Synchronization

Learn how local UI, server, URL, form, session, derived, persistent, and remote state differ, and how single ownership, state machines, reducers, normalization, optimistic updates, caches, subscriptions, persistence, and debugging help.

#technology#state-management#frontend#application-architecture

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 128

Offline-First Applications: Local Work With Deliberate Synchronization

Learn how offline-first apps use local data, operation logs, optimistic UI, synchronization, connectivity state, conflict detection and resolution, tombstones, retries, security, migrations, storage limits, testing, and user feedback.

#technology#offline-first#mobile-apps#synchronization

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 127

Push Notifications: Delivering Timely Signals Through Platform Services

Learn how app servers, platform push services, device tokens, payloads, notification and data messages, permissions, delivery limits, deep links, security, privacy, token lifecycle, retries, localization, and measurement work.

#technology#push-notifications#mobile-apps#messaging

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 126

Mobile App Permissions: Contextual Access to Sensitive Capabilities

Learn how mobile permissions protect location, camera, microphone, contacts, photos, notifications, and background activity, and how timing, explanation, scope, denial, revocation, privacy, testing, and platform changes affect design.

#technology#mobile-permissions#privacy#mobile-apps

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 125

Native, Web, and Cross-Platform Apps: Choosing a Mobile Delivery Model

Compare native, mobile web, progressive web, and cross-platform applications across device APIs, performance, UI, distribution, updates, offline use, accessibility, security, code sharing, team skills, and product fit.

#technology#mobile-apps#native-apps#cross-platform#web-apps

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 124

Accessibility: Designing Digital Products for Reliable Human Access

Learn how semantic HTML, keyboard access, focus, screen readers, labels, headings, contrast, zoom, motion, captions, errors, cognitive clarity, mobile accessibility, testing, and team processes create accessible products.

#technology#accessibility#inclusive-design#web-development

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 123

Responsive Design: Preserving Usability Across Space, Input, and Context

Learn how fluid layouts, media and container queries, content priority, breakpoints, images, typography, touch, tables, navigation, zoom, orientation, safe areas, performance, and testing create responsive interfaces.

#technology#responsive-design#web-design#accessibility

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 122

Single-Page Applications: Browser-Resident Applications With Client Routing

Learn how SPAs load an application shell, route in the browser, fetch APIs, manage state, update history, code-split, cache, support accessibility, handle failures, secure sessions, and compare with multi-page and hybrid apps.

#technology#single-page-applications#spa#web-development

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 121

Server-Side Rendering and Client-Side Rendering: Where Web Interfaces Take Shape

Learn how server-side and client-side rendering produce web interfaces, how hydration, streaming, static generation, caching, personalization, navigation, performance, resilience, SEO, and hybrid design affect the choice.

#technology#server-side-rendering#client-side-rendering#web-development

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 120

API Versioning and Compatibility: Evolving Contracts Without Surprise

Learn what makes API changes breaking, how additive evolution, tolerant clients, URL and header versions, schema changes, deprecation, telemetry, contract tests, consumer migration, version support, and semantic compatibility work.

#technology#api-versioning#compatibility#api

Jul 16, 20267 min readSeries: Tech Explained Simply · Part 119

Rate Limiting: Protecting Capacity, Cost, and Fair Access

Learn why APIs rate limit, how fixed windows, sliding windows, token buckets, leaky buckets, quotas, concurrency limits, distributed counters, identity keys, headers, retries, login protection, and adaptive controls work.

#technology#rate-limiting#api#reliability