Software Development — A Guided Tour

Chapter 01

Foundations of Programming

Before frameworks and clouds, there are ideas. A program is a set of precise instructions a computer follows to turn input into output.

Basic Concepts

Program: step-by-step instructions written in a programming language.
Variables & Data Types: named containers (numbers, text, booleans, lists, objects).
Control Flow: if, loops, functions — decide what runs, when, and how many times.
Compile vs Interpret: compiled languages (Java, Go, C++) are translated ahead of time; interpreted ones (Python, JavaScript) run line by line.
Algorithm: a recipe to solve a problem. Data Structure: how you arrange data (array, list, map, tree, graph).

Programming Paradigms — click any card for the deep dive

Procedural →

Straight-line steps. C, early BASIC. Easy to start, hard to scale.

Object-Oriented (OOP) →

Data + behavior bundled into objects. Java, C#, Python. Dominates enterprise software.

Functional →

Pure functions, immutability. Haskell, F#, Elixir. Concepts now mainstream in JS/Python.

Declarative →

Describe what, not how. SQL, HTML, React JSX.

Computer Science Essentials

Memory

Stack & Heap

Stack = fast, short-lived values. Heap = objects that outlive a function call.

Time

Big-O Notation

How runtime grows with input size. O(1), O(log n), O(n), O(n²).

Structure

Core Data Structures

Array, linked list, hash map, stack, queue, tree, graph. Pick based on access pattern.

Flow

Concurrency

Threads, async/await, event loops. Runs many things at once without chaos.

Operating Systems & Environment

Why it matters

Every program runs on an OS. It manages files, memory, processes, networking, and security.

Topic	What a beginner should know
Processes & Threads	Isolated running programs vs lightweight workers inside one program.
File System	Paths, permissions, current working directory.
Shell / Terminal	Bash / Zsh / PowerShell — text commands to control the OS.
Environment Variables	Config values (`PATH`, `API_KEY`) read by running programs.
Package Managers (OS)	`apt`, `brew`, `choco`, `winget` — install software.

Source Code, Binary, and Runtime

Source code (.java, .py)

→

Compile / Interpret

→

Bytecode / Native binary

→

Runtime (JVM, V8, .NET CLR)

→

OS → CPU

The runtime is where your code actually executes. Java on JVM, JavaScript on V8 (Node/Chrome), C# on .NET CLR. Understanding the runtime helps you debug and tune performance.

Chapter 02

Client Side

↑ Back to Map

"Client side" means code that runs on the user's device — the part they see, click, and feel.

Basic Concepts

HTML describes structure, CSS describes style, JavaScript adds behavior.
DOM = the live tree of elements the browser renders; JS changes the DOM to update the UI.
Responsive design makes one page look good on phone, tablet, and desktop.
SPA vs MPA: Single-Page Apps update without full reloads; Multi-Page Apps navigate between server-rendered pages.
Rendering modes: CSR (browser), SSR (server), SSG (build-time), and ISR (hybrid).

Client Platforms

Web

Runs in any browser. HTML/CSS/JS + TypeScript. Most reach, least control of device.

Mobile (Native)

iOS (Swift/SwiftUI), Android (Kotlin/Jetpack Compose). Full device power, store distribution.

Mobile (Cross-platform)

React Native, Flutter (Dart), .NET MAUI. One codebase → both stores.

Desktop

Electron, Tauri, WPF, JavaFX, Qt. Usually web tech wrapped as an app.

TV / Embedded / Wearables

Smart TVs, kiosks, cars, watches — specialized SDKs and constraints.

PWA

Progressive Web App — web that installs like an app and works offline.

Popular Web Frameworks — framework names link to deep dives

Framework	Backed by	Language	Why it matters
React →	Meta	JS / TypeScript	Component-based, the de-facto default, enormous ecosystem.
Angular →	Google	TypeScript	Opinionated and complete — popular for large enterprise apps.
Vue →	Community	JS / TS	Gentle learning curve, approachable templates.
Svelte →	Community	JS / TS	Compiles away — smallest bundles, fastest runtime.
Solid →	Community	JS / TS	React-like API with fine-grained reactivity.
Next.js →	Vercel	React	Full-stack React — routing, SSR, server components.
Nuxt →	Community	Vue	Next-style framework for Vue.
SvelteKit →	Community	Svelte	Full-stack Svelte apps.

Mobile Frameworks — framework names link to deep dives

iOS

SwiftUI →

Apple's native declarative framework. Best performance on Apple devices. (Language: Swift.)

Android

Jetpack Compose →

Google's native declarative toolkit for Android. (Language: Kotlin.)

Cross

Flutter →

Dart language; renders its own UI for pixel-identical look across platforms.

Cross

React Native →

Reuses React skills; native components under the hood. (Language: JavaScript.)

Cross

.NET MAUI →

C# everywhere — Microsoft's successor to Xamarin. (Language: C#.)

Cross

Kotlin Multiplatform →

Share business logic across iOS, Android, web; native UI per platform. (Language: Kotlin.)

Hybrid

Ionic + Capacitor →

Web technology wrapped as a native app; React/Vue/Angular inside.

Client-Side Tooling

Bundle

Bundlers

Webpack, Vite, esbuild, Parcel, Rollup — package many files for the browser.

Install

Package Managers

npm, pnpm, yarn — install JavaScript libraries.

Translate

Transpilers

Babel, TypeScript, SWC — modern/typed code → browser JS.

Style

CSS Systems

Tailwind, Sass, CSS Modules, styled-components, design tokens.

State

State Management

Redux, Zustand, Pinia, NgRx, React Query, SWR.

UI Kits

Component Libraries

Material UI, Ant Design, shadcn/ui, Chakra, Bootstrap.

Accessibility

a11y

Screen readers, ARIA roles, keyboard nav, color contrast. Legal in many regions.

i18n

Internationalization

Multiple languages, currencies, dates, right-to-left layouts.

Chapter 03

Server Side

↑ Back to Map

Servers run the business logic — authentication, transactions, integrations, background work — and expose it through APIs.

Basic Concepts

Server: a program (and the machine it runs on) that waits for requests and responds.
Request/Response: clients send a request, the server returns a response. Usually over HTTP.
Stateless vs Stateful: stateless servers keep nothing between requests — easier to scale.
Business logic = the rules of your domain (pricing, approvals, workflows).
Concurrency: handling many users at once via threads, async loops, or many processes.

Languages on the Server — click any card for the deep dive

Enterprise

Java →

Strongly typed, long-lived; backs banks, airlines, telcos.

Microsoft

C# / .NET →

Excellent tooling; the Microsoft-shop default.

Versatile

Python →

Readable, huge libraries; web, data, AI, scripting.

Full-stack

Node.js (JS) →

Same language as the browser; fast iteration. Often paired with TypeScript for type safety.

Cloud-native

Go →

Small binaries, fast startup; built at Google.

Safety

Rust →

Memory-safe systems language; growing in backend & infra.

Web

Ruby →

Developer-friendly; famous for Rails.

JVM

Kotlin →

Modern JVM language; runs Android too. (Scala is its sibling.)

Systems

C++ →

Performance-critical engines, browsers, trading, games.

Scripting

PHP →

Still powers a huge share of the web (WordPress, Laravel).

Backend Frameworks — framework names link to deep dives

Language	Framework	Why it matters
Java	Spring Boot →	Convention-over-config. The enterprise standard.
Java	Quarkus / Micronaut	Lightweight, cloud-native, fast startup.
C# / .NET	ASP.NET Core →	High-performance web & API framework.
Python	Django →	Full-featured — admin, ORM, auth included.
Python	FastAPI → / Flask	Minimal APIs; type hints and async.
Node.js	Express → / NestJS → / Fastify	From minimal (Express) to opinionated (Nest).
Go	Gin → / Echo / Fiber	Blazing-fast HTTP routers.
Ruby	Ruby on Rails →	The classic full-stack, convention-driven framework.
PHP	Laravel → / Symfony	Modern PHP frameworks with rich ecosystems.
Kotlin	Ktor →	Kotlin-native backend framework.

Server Responsibilities

Authentication & Sessions

Who are you? JWT, OAuth, cookies, SSO.

Authorization

What can you do? RBAC, ABAC, permissions.

Validation

Never trust input — validate at every boundary.

Persistence

Talk to databases via ORMs or query builders.

Integrations

Payments, email, SMS, 3rd-party APIs.

Background Jobs

Queue long tasks: reports, emails, ML scoring.

Chapter 04

Database Side

↑ Back to Map

Databases are how software remembers things safely, quickly, and at scale.

Basic Concepts

Schema: the shape of your data (tables, columns, types).
CRUD: Create, Read, Update, Delete — the four basic operations.
ACID: Atomicity, Consistency, Isolation, Durability — transactional guarantees.
Index: a shortcut that makes reads fast; a trade-off that slows writes.
Normalization: splitting data to avoid duplication. Denormalization: duplicating on purpose for speed.

SQL vs NoSQL

SQL (Relational)

Strict schema, ACID, joins. Best for money, orders, anything with invariants.

Examples: PostgreSQL, MySQL, SQL Server, Oracle, SQLite.

NoSQL

Flexible schemas, horizontal scale. Great for unstructured or massive data.

Families: document, key-value, column, graph.

Database Families & When to Use Them

Family	Examples	Best for
Relational	PostgreSQL, MySQL, SQL Server	Transactions, joins, strong consistency.
Document	MongoDB, Couchbase	JSON-like records, flexible shape.
Key-Value	Redis, DynamoDB	Ultra-fast lookups, caches, sessions.
Column	Cassandra, HBase, ScyllaDB	Huge writes, time-series.
Graph	Neo4j, Amazon Neptune	Deep relationships — fraud, recommendations.
Search	Elasticsearch, OpenSearch	Full-text search, logs, observability.
Vector	Pinecone, Weaviate, pgvector	AI embeddings — semantic search, RAG.
Warehouse / Lake	Snowflake, BigQuery, Databricks	Analytics at scale; historical reporting.
Time-Series	InfluxDB, TimescaleDB	Metrics, IoT, sensor data.

ORMs & Data Access

Java

Hibernate / JPA

Map objects ↔ tables. Venerable, powerful.

.NET

Entity Framework

LINQ queries, migrations.

Python

SQLAlchemy / Django ORM

The two Python standards.

Node

Prisma / TypeORM / Drizzle

Type-safe database access for TS.

Ruby

ActiveRecord

Rails' iconic ORM.

All

Raw SQL / Query Builders

Knex, jOOQ, sqlx — hand-crafted control when ORMs get in the way.

Caching & Performance

Databases are often the bottleneck. Caching is the first optimization most apps reach for.

Application cache: in-memory (Guava, Caffeine).
Distributed cache: Redis, Memcached.
CDN cache: Cloudflare, CloudFront, Fastly — cache at the edge, close to users.
Read replicas: offload reads to secondary DB copies.
Sharding: split one database into many by key.

Chapter 05

APIs & Networking

↑ Back to Map

APIs are the contracts between systems — and networking is how they talk.

Basic Concepts

API (Application Programming Interface): a defined way one system calls another.
HTTP: the request/response protocol of the web. Verbs: GET, POST, PUT, DELETE.
JSON is the common data format for APIs.
DNS turns example.com into an IP address.
TLS / HTTPS encrypts the traffic end-to-end.

API Styles

REST

Resources + HTTP verbs. Simple, cacheable, ubiquitous.

GraphQL

Client asks for exactly the fields it needs. One endpoint.

gRPC

Binary protocol using Protocol Buffers. Very fast for service-to-service.

WebSockets

Two-way always-on channel. Chats, dashboards, games.

SOAP

XML-based, heavy but still seen in legacy enterprise.

Webhooks

Reverse APIs — the server calls you when an event happens.

Server-Sent Events

One-way stream from server to client.

Networking Fundamentals

Client

→

DNS lookup

→

TCP + TLS handshake

→

HTTP request

→

Server

→

Response

Concept	Beginner explanation
IP & Port	IP identifies a machine; port identifies a program on it (e.g. 443 for HTTPS).
TCP vs UDP	TCP is reliable & ordered (web). UDP is fast & lossy (video/game).
CORS	Browsers block cross-site requests by default; the server must opt in.
Load Balancer	Distributes requests across many servers.
Reverse Proxy	Sits in front of your app (nginx, HAProxy) — TLS, caching, routing.

Messaging & Event Streaming

When services don't want to wait for each other, they exchange messages.

Message Queues

RabbitMQ, ActiveMQ, Amazon SQS. One producer → one consumer, with durable delivery.

Event Streaming

Apache Kafka, AWS Kinesis, Google Pub/Sub. Replayable logs of events, many consumers.

Pub/Sub

Publishers broadcast events; subscribers listen. Decoupling 101.

Chapter 06

Architecture & Design Patterns

↑ Back to Map

Architecture is about the big-picture shape — how pieces fit, scale, and evolve.

Basic Concepts

Separation of Concerns: each piece of code has one job.
Coupling vs Cohesion: aim for low coupling between modules, high cohesion within them.
Scalability: vertical (bigger machine) vs horizontal (more machines).
Availability: how often the system is up. 99.9% ≈ 8h downtime/year.
Consistency vs Availability (CAP): in a partition, you pick one.

Architectural Styles

Monolith

One deployable app. Simple early on; hard to scale teams.

Modular Monolith

Monolith with strict internal boundaries. Often the right default.

Microservices

Many small services, independently deployed. Powerful but complex.

Serverless

Functions triggered by events. No servers to manage.

Event-Driven

Services communicate via events on a bus. Loose coupling, eventual consistency.

Layered / N-tier

Presentation → Application → Domain → Data. The classic.

Hexagonal / Clean

Domain core, adapters on the edges. Swap DB or UI without touching logic.

CQRS + Event Sourcing

Separate read/write models; store events, not state.

Design Principles (SOLID & Friends)

S — Single Responsibility: one reason to change per class.
O — Open/Closed: open to extension, closed to modification.
L — Liskov Substitution: subtypes must work where the base type is used.
I — Interface Segregation: many small interfaces beat one big one.
D — Dependency Inversion: depend on abstractions, not concretes.
DRY (Don't Repeat Yourself), KISS (Keep It Simple), YAGNI (You Aren't Gonna Need It).

Common Design Patterns

Creational

Singleton, Factory, Builder, Prototype.

Structural

Adapter, Decorator, Facade, Proxy, Composite.

Behavioral

Strategy, Observer, Command, Iterator, State.

Enterprise

Repository, Unit of Work, DTO, Dependency Injection.

Chapter 07

Security

↑ Back to Map

Security isn't a feature you bolt on — it's a property you design for.

Basic Concepts

Authentication (AuthN): who are you? (password, SSO, biometric)
Authorization (AuthZ): what are you allowed to do? (roles, permissions)
Encryption at rest (stored data) vs in transit (TLS/HTTPS).
Hashing is one-way (passwords). Encryption is reversible (with a key).
Principle of Least Privilege: give every user/system the minimum access needed.

OWASP Top 10 (Common Web Vulnerabilities)

Injection

SQL injection, command injection. Always use parameterized queries.

Broken Access Control

Users accessing data they shouldn't — #1 most common.

XSS

Cross-site scripting — attacker's JS runs in your page.

CSRF

A malicious site makes the browser perform actions as the logged-in user.

Broken Authentication

Weak passwords, no MFA, leaky sessions.

Insecure Deserialization

Untrusted data → code execution.

Vulnerable Dependencies

Old libraries with known CVEs.

Security Misconfiguration

Default passwords, verbose errors, open S3 buckets.

Auth Standards

Standard	Purpose
OAuth 2.0	Delegated authorization — "let this app read my Google calendar".
OpenID Connect (OIDC)	Authentication layer on top of OAuth — "who am I?".
SAML	Enterprise SSO (older, XML-based).
JWT	Signed token format; commonly carries auth claims.
MFA / 2FA	Second factor (authenticator app, hardware key).
Passkeys / WebAuthn	Modern passwordless authentication.

Secure Development Practices

Never commit secrets. Use secret managers (AWS Secrets Manager, HashiCorp Vault).
Scan dependencies (Dependabot, Snyk) and container images.
Run SAST (static analysis) and DAST (dynamic) tools in CI.
Threat model new features before building them.
Rotate keys; audit access logs; patch promptly.
Understand relevant compliance: GDPR, HIPAA, PCI-DSS, SOC 2, ISO 27001.

Chapter 08

Testing & Code Quality

↑ Back to Map

Tests are how we move fast without breaking things. Quality tools keep codebases readable for years.

Basic Concepts

Test pyramid: lots of fast unit tests at the base, fewer integration tests in the middle, very few slow E2E tests at the top.
TDD: write the failing test first, then the code that makes it pass.
Coverage: how much code your tests exercise — useful but not a quality measure by itself.
Static analysis: tools that find bugs without running code.
Code review: a human reads your change before it merges.

Test Types

Unit

One function/class in isolation. Fast, many.

Integration

Multiple parts together, possibly a real DB.

End-to-End (E2E)

Full system through a real browser or API.

Contract

Verify service producers and consumers agree (Pact).

Performance / Load

k6, JMeter, Gatling — how it behaves under stress.

Smoke

Minimal "does it start?" tests in production.

Regression

Ensures old bugs stay fixed.

Chaos

Deliberately break things (Netflix Chaos Monkey) to prove resilience.

Testing Frameworks

Stack	Unit / Integration	E2E
Java	JUnit, TestNG, Mockito	Selenium
.NET	xUnit, NUnit, MSTest	Playwright, Selenium
Python	pytest, unittest	Playwright, Selenium
JS / TS	Jest, Vitest, Mocha	Playwright, Cypress
Ruby	RSpec, Minitest	Capybara
Go	testing, testify	Playwright

Code Quality Tools

Lint

Linters

ESLint, Pylint, RuboCop, Checkstyle — enforce style, catch bugs.

Format

Formatters

Prettier, Black, gofmt, Spotless — zero-config consistent style.

SAST

Static Analysis

SonarQube, Semgrep, CodeQL — deep bug & security scanning.

Types

Type Checking

TypeScript, mypy, Flow — compile-time safety for dynamic languages.

Review

PR / Code Review

GitHub PRs, GitLab MRs, Gerrit — human sanity check.

Docs

Doc Generators

Javadoc, JSDoc, Sphinx, Doxygen — API docs from comments.

Chapter 09

Cross-Cutting Tools

↑ Back to Map

These tools show up in nearly every project, regardless of stack.

Basic Concepts

Version control tracks every change; Git is the universal standard.
Build tool turns source into a shippable artifact (jar, container, bundle).
Package manager installs and versions your dependencies.
IDE is your writing environment — editor + debugger + refactoring.

Version Control

Git

Distributed version control — the standard.

GitHub

Hosting, PRs, Actions (CI/CD), Copilot.

GitLab

Hosting + built-in CI/CD, often self-hosted.

Bitbucket

Atlassian — integrates with Jira.

Azure DevOps

Microsoft's full ALM suite.

Mercurial / SVN

Legacy systems still found in older projects.

Key Git concepts: clone, branch, commit, merge, rebase, pull request. Common workflows: GitFlow, trunk-based.

Build Tools & Package Managers

Stack	Tool	Purpose
Java	Maven, Gradle	Dependencies, builds, packaging JAR/WAR.
JavaScript / TS	npm, pnpm, yarn + Vite / Webpack	Install libs + bundle browser code.
.NET	dotnet CLI, NuGet, MSBuild	Restore, compile, package .NET.
Python	pip, Poetry, uv, pipenv	Dependency & environment management.
C / C++	CMake, Make, Bazel	Cross-platform native builds.
Go / Rust	go build, cargo	Single-binary compilation baked in.
Ruby	Bundler + RubyGems	Ruby dependency management.
Mobile	Gradle, CocoaPods, SwiftPM	Android & iOS packaging.

IDEs & Editors

VS Code

The most popular editor — free, extensible, everywhere.

JetBrains Suite

IntelliJ (Java), PyCharm, WebStorm, Rider, GoLand. Best-in-class refactoring.

Visual Studio

Full IDE for .NET and C++ on Windows.

Neovim / Emacs

Keyboard-driven power tools for enthusiasts.

Cursor / Claude Code / Copilot

AI-native editors — pair-programmers built in.

Project & Issue Tracking

Jira

Enterprise standard for backlogs & sprints.

Linear

Fast, opinionated, developer-favorite.

GitHub Issues / Projects

Tightly integrated with the repo.

Trello / Asana / ClickUp

Lightweight boards for small teams.

Confluence / Notion

Team wikis and documentation.

Chapter 10

DevOps & CI/CD

↑ Back to Map

DevOps closes the gap between writing code and running it in production — through automation.

Basic Concepts

CI (Continuous Integration): every change is automatically built and tested.
CD (Continuous Delivery / Deployment): every green build is deployable — or actually deployed.
Container: a lightweight, portable unit bundling app + dependencies.
IaC (Infrastructure as Code): describe servers/networks in code, apply like software.
Shift left: move testing, security, and quality checks earlier in the pipeline.

CI/CD Platforms

GitHub Actions

YAML workflows, huge marketplace.

GitLab CI

Built into GitLab; mature and full-featured.

Jenkins

Battle-tested, plugin-rich, self-hosted.

CircleCI / Travis / TeamCity

Other long-standing CI services.

Azure Pipelines

Microsoft's offering — works for any language.

ArgoCD / Flux

GitOps — deploy to Kubernetes from Git.

Containers & Orchestration

Build

Docker / Podman

Package your app + runtime into a portable image.

Run many

Kubernetes (K8s)

Orchestrates containers across clusters — the de-facto standard.

Managed

EKS / AKS / GKE

Managed K8s from AWS / Azure / Google.

Simple

ECS / Docker Swarm / Nomad

Simpler alternatives to Kubernetes.

Packaging

Helm

Package manager for Kubernetes apps.

Mesh

Service Mesh

Istio, Linkerd — traffic, security, observability between services.

Infrastructure as Code (IaC)

Tool	Strength
Terraform / OpenTofu	Cloud-agnostic, declarative — describe infra in HCL.
AWS CloudFormation	Native to AWS; very deep integration.
Pulumi	IaC using real programming languages (TS, Python, Go).
Ansible	Configuration management — agentless, YAML playbooks.
Chef / Puppet	Older configuration management stalwarts.

Deployment Strategies

Rolling: replace instances a few at a time.
Blue/Green: spin up a full new env, switch traffic instantly, roll back if needed.
Canary: send 1–5% of traffic to new version, expand if healthy.
Feature flags: ship code dark, turn it on for subsets of users.

Chapter 11

Methodologies & SDLC

↑ Back to Map

How teams organize work, prioritize, and ship — from classic Waterfall to modern DevOps.

Basic Concepts

SDLC (Software Development Life Cycle): Requirements → Design → Build → Test → Deploy → Maintain.
Agile is a mindset of iteration and feedback — not a single process.
Scrum & Kanban are two concrete Agile flavors.
DevOps unites developers and operations via automation and shared ownership.

Methodologies

Waterfall

Sequential phases. Predictable, inflexible to change.

Agile

Short iterations, constant feedback, adapt to change.

Scrum

Sprints (2 weeks), stand-ups, backlog, retros, roles.

Kanban

Continuous flow on a board, limit work-in-progress.

XP (Extreme Programming)

Pair programming, TDD, continuous integration.

Lean

Eliminate waste; focus on value delivery.

SAFe / LeSS

Scaled Agile for big organizations.

DevOps

Dev + Ops + automation + shared metrics.

Scrum Roles & Ceremonies

Role / Ceremony	Purpose
Product Owner	Owns priorities; decides what to build.
Scrum Master	Coaches the team; removes blockers.
Developers	Build the increment every sprint.
Sprint Planning	Pick goals & items for the next sprint.
Daily Stand-up	15 min sync on progress & blockers.
Sprint Review	Demo the increment to stakeholders.
Retrospective	Reflect on how to work better.

Estimation & Planning

Story points (relative effort) vs hours (absolute). Teams usually pick one.
Planning Poker — collaborative estimation using cards.
Velocity — story points completed per sprint.
Definition of Done — what "finished" means (tests, docs, deployed).
User Stories: "As a <role>, I want <goal>, so that <benefit>."

Chapter 12

Cloud Computing

↑ Back to Map

You rent computing on demand, pay only for what you use, and scale in minutes instead of months.

Basic Concepts

Region = geographic area. Availability Zone = isolated datacenter within a region.
Elasticity: scale up & down automatically with demand.
Pay-as-you-go pricing — but watch for hidden costs (egress, idle resources).
Shared Responsibility: cloud secures the platform, you secure your data & config.

Service Models — click any card for the deep dive

Provider	Strength	Signature services
AWS →	Largest, most services.	EC2, S3, Lambda, RDS, DynamoDB
Microsoft Azure →	Strong enterprise + Microsoft stack.	App Service, Functions, Cosmos DB, AKS
Google Cloud →	Best-in-class data & AI.	BigQuery, Vertex AI, Cloud Run, GKE
Oracle Cloud →	Oracle DB workloads.	OCI Compute, Autonomous DB
DigitalOcean / Linode →	Simple developer-friendly pricing.	Droplets, App Platform
Vercel / Netlify / Cloudflare →	Edge & front-end hosting.	Edge Functions, static hosting

Cloud-Native Patterns

Stateless workers → scale horizontally behind a load balancer.
Managed services wherever possible — less plumbing to maintain.
Event-driven — queues & streams decouple producers and consumers.
12-Factor App — config via env vars, stateless processes, port binding, etc.
FinOps — track & optimize cloud spend like a first-class engineering concern.

Chapter 13

Observability & Performance

↑ Back to Map

You can't fix what you can't see. Observability gives you eyes inside a running system.

Basic Concepts — The Three Pillars of Observability

Logs: text records of events — "user X logged in at 3:42pm".
Metrics: numbers over time — CPU, requests/sec, error rate.
Traces: follow one request through many services.
SLI / SLO / SLA: what you measure, what you promise internally, what you promise externally.

Tools & Platforms

Logs

ELK / OpenSearch / Loki

Collect, index, and search log streams.

Metrics

Prometheus + Grafana

Open-source default for metrics & dashboards.

Traces

Jaeger / Zipkin / OpenTelemetry

Distributed tracing — OTel is the emerging standard.

All-in-one

Datadog / New Relic / Honeycomb

Commercial platforms unifying the three pillars.

Alerts

PagerDuty / Opsgenie

Wake the right person when things break.

Errors

Sentry / Rollbar

Crash & exception tracking for apps.

Performance & Scalability

Vertical scaling: bigger box — simple, limited.
Horizontal scaling: more boxes — needs stateless design.
Caching layers: CDN → reverse proxy → app cache → DB.
Profiling: find hot spots (CPU, memory, SQL) before optimizing.
Load testing: k6, JMeter, Gatling — simulate real traffic.
Rate limiting & backpressure protect services from overload.

Chapter 14

AI Landscape

↑ Back to Map

The newest layer in the stack — and it changes both what we build and how we build it.

Basic Concepts

Model: a mathematical function trained on data to make predictions or generate content.
LLM (Large Language Model): predicts the next token of text — GPT, Claude, Gemini.
Embedding: a numerical vector that captures meaning of text/images.
RAG (Retrieval-Augmented Generation): fetch relevant docs → feed into the LLM.
Prompt: the instruction & context you send to the model.
Fine-tuning: further-train a model on your own data.

The AI Stack Layers — click any card for the deep dive

Hallucinations — LLMs can confidently invent facts. Validate outputs.
Bias & fairness — models reflect training data; audit for disparate impact.
Privacy — never send sensitive data to third-party APIs without review.
Prompt injection — a new attack surface; treat model output as untrusted input.
Evaluation — golden sets, LLM-as-judge, human review. Ship what you can measure.

Chapter 15

Soft Skills & Ecosystem

↑ Back to Map

Code is only half the job. The rest is people, writing, and the wider ecosystem you work in.

Basic Concepts

Clear writing is the most valuable developer skill — PRs, docs, incident reports.
Code review is about learning, not gatekeeping.
Open source underpins nearly every project you'll ever build.
Licenses matter — not every "free" library is safe to ship commercially.

Developer Soft Skills

Communication

Explain tradeoffs in plain language to non-technical stakeholders.

Collaboration

Pair programming, constructive code review, async updates.

Problem Decomposition

Break big problems into independently shippable pieces.

Time & Focus

Deep work, protecting schedules, avoiding endless yak-shaving.

Learning to Learn

Tech moves fast — skill of picking up new tools efficiently.

Debugging Mindset

Forming hypotheses, isolating variables, reading carefully.

Open Source & Licensing

License family	Practical meaning
MIT / BSD / Apache 2.0	Permissive — use freely, even in closed-source commercial products.
GPL / AGPL	Copyleft — using it may require you to also release your code.
LGPL	Weaker copyleft — linking is typically OK.
Creative Commons	For content (docs, images) — not code.
Proprietary / Commercial	Check the EULA — often per-seat or per-core pricing.

Rule of thumb: before adopting a library, check its license and whether it fits your product's shipping model.

Documentation & Writing

README — what it is, how to run it, how to contribute.
Architecture Decision Records (ADRs) — short notes on why a design choice was made.
Runbooks — step-by-step guides for common operational tasks.
Postmortems — blameless write-ups after incidents.
API docs — OpenAPI/Swagger for REST, Schema Introspection for GraphQL.

Career & Community

Community Sites

Stack Overflow, Reddit, Dev.to, Hacker News.

Learning

freeCodeCamp, Coursera, Pluralsight, Frontend Masters.

Portfolio

GitHub profile, personal site, blog posts — show the work.

Interview Prep

LeetCode, HackerRank, System Design Primer.

The Software Development Map

Foundations of Programming

Basic Concepts

Procedural →

Object-Oriented (OOP) →

Functional →

Declarative →

Stack & Heap

Big-O Notation

Core Data Structures

Concurrency

Why it matters

Client Side

Basic Concepts

Web

Mobile (Native)

Mobile (Cross-platform)

Desktop

TV / Embedded / Wearables

PWA

Bundlers

Package Managers

Transpilers

CSS Systems

State Management

Component Libraries

a11y

Internationalization

Server Side

Basic Concepts

Java →

C# / .NET →

Python →

Go →

Rust →

Ruby →

Kotlin →

C++ →

PHP →

Authentication & Sessions

Authorization

Validation

Persistence

Integrations

Background Jobs

Database Side

Basic Concepts

SQL (Relational)

NoSQL

Hibernate / JPA

Entity Framework

SQLAlchemy / Django ORM

Prisma / TypeORM / Drizzle

ActiveRecord

Raw SQL / Query Builders

APIs & Networking

Basic Concepts

REST

GraphQL

gRPC

WebSockets

SOAP

Webhooks

Server-Sent Events

Message Queues

Event Streaming

Pub/Sub

Architecture & Design Patterns

Basic Concepts

Monolith

Modular Monolith

Microservices

Serverless

Event-Driven

Layered / N-tier

Hexagonal / Clean

CQRS + Event Sourcing

Creational

Structural

Behavioral