# DevPath > Free, structured lessons on data structures, algorithms, systems, and modern AI engineering (vectors, embeddings, RAG), with Python and JavaScript examples, practice problems, and interview questions. All lessons are original, free, and include Python and JavaScript examples, practice problems, and interview questions. The full text of every lesson is available in one file at https://devpath.abhihyder.com/llms-full.txt. ## Foundations Complexity, memory, and how computers actually run your code. - [How to Study Programming](https://devpath.abhihyder.com/learn/foundations/how-to-study): Learning strategies that actually stick: active recall, spaced repetition, deliberate practice, and a repeatable framework for attacking problems you have never seen. - [Big-O and Complexity Analysis](https://devpath.abhihyder.com/learn/foundations/big-o): Measure how an algorithm's cost grows with input size, read common complexity classes at a glance, and reason about time, space, and amortized cost. - [How Computers Run Programs](https://devpath.abhihyder.com/learn/foundations/how-computers-run-programs): From source code to electrons: the CPU's fetch-execute loop, the memory hierarchy, compiled versus interpreted languages, and how the call stack tracks function calls. - [Memory, References, and Pointers](https://devpath.abhihyder.com/learn/foundations/memory-and-pointers): Stack versus heap, what a pointer or reference really is, how garbage collection reclaims memory, and how aliasing works in Python and JavaScript. - [Bitwise Operations](https://devpath.abhihyder.com/learn/foundations/bitwise-operations): Work directly with the bits of integers: AND, OR, XOR, NOT, shifts, masks, flags, and classic tricks like counting bits and finding the unpaired number. - [Floating-Point Numbers](https://devpath.abhihyder.com/learn/foundations/floating-point): Why 0.1 + 0.2 is not 0.3: how IEEE 754 stores real numbers, where rounding error comes from, and how to compare, sum, and store money safely. - [Unicode, Encodings, and Endianness](https://devpath.abhihyder.com/learn/foundations/unicode-and-encodings): How text becomes bytes: code points, UTF-8, why length depends on what you count, mojibake, and how byte order (endianness) changes the layout of numbers. ## Data Structures & Algorithms The core toolkit every interview and every large codebase relies on. - [Arrays and Dynamic Arrays](https://devpath.abhihyder.com/learn/core-dsa/arrays): How arrays sit in memory, why indexing is instant, and how a growable array amortizes its cost. - [Linked Lists](https://devpath.abhihyder.com/learn/core-dsa/linked-lists): Nodes joined by pointers: how singly and doubly linked lists work, plus the reverse, dummy-node and fast/slow pointer patterns. - [Stacks and Queues](https://devpath.abhihyder.com/learn/core-dsa/stacks-and-queues): LIFO and FIFO containers, the call stack, monotonic stacks, deques and circular buffers, with implementations and their costs. - [Hash Tables](https://devpath.abhihyder.com/learn/core-dsa/hash-tables): How a hash function turns keys into array slots, what collisions and load factor mean, and how to build a table with chaining. - [Binary Search](https://devpath.abhihyder.com/learn/core-dsa/binary-search): Halve a search space every step: the lower-bound template, boundary pitfalls, and searching on the answer instead of an array. - [Recursion](https://devpath.abhihyder.com/learn/core-dsa/recursion): Solve a problem by solving smaller copies of it: base cases, the call stack, divide and conquer, and memoization as a first step to dynamic programming. - [Sorting](https://devpath.abhihyder.com/learn/core-dsa/sorting): Insertion, merge and quick sort compared, plus stability, why comparison sorts need n log n, and when counting sort beats them. - [Trees and Binary Search Trees](https://devpath.abhihyder.com/learn/core-dsa/trees-and-bst): Hierarchical data, the four classic traversals, and how a binary search tree gives ordered search, insert and delete in O(h) time. - [Heaps and Priority Queues](https://devpath.abhihyder.com/learn/core-dsa/heaps): The binary heap: how an array stores a tree, why push and pop cost O(log n), why heapify is O(n), and the top-k pattern. - [Tries (Prefix Trees)](https://devpath.abhihyder.com/learn/core-dsa/tries): A tree keyed by characters that makes prefix search, autocomplete and word lookup cost O(length of the word), independent of dictionary size. - [Graphs: Representations, BFS and DFS](https://devpath.abhihyder.com/learn/core-dsa/graphs): Model networks as vertices and edges, choose between adjacency lists and matrices, and explore with breadth-first and depth-first search. - [Graph Algorithms: Dijkstra, Topological Sort, Cycles, Components](https://devpath.abhihyder.com/learn/core-dsa/graph-algorithms): Weighted shortest paths with Dijkstra, ordering tasks with topological sort, detecting cycles, and counting connected components. - [Two Pointers and Sliding Window](https://devpath.abhihyder.com/learn/core-dsa/two-pointers-sliding-window): Turn nested loops into a single pass by moving two indexes cleverly: opposite-end pointers, fast and slow pointers, and windows that grow and shrink. - [Backtracking](https://devpath.abhihyder.com/learn/core-dsa/backtracking): Explore choices one at a time, undo them when they fail, and prune whole branches early. Subsets, permutations, and N-Queens. - [Dynamic Programming](https://devpath.abhihyder.com/learn/core-dsa/dynamic-programming): Solve a problem by breaking it into overlapping sub-problems and remembering each answer. Top-down vs bottom-up, coin change, LCS, and knapsack. - [Greedy Algorithms](https://devpath.abhihyder.com/learn/core-dsa/greedy): Make the best local choice at every step and never look back. Interval scheduling, the exchange argument, and how to spot when greedy fails. - [Union-Find (Disjoint Sets)](https://devpath.abhihyder.com/learn/core-dsa/union-find): Track which items belong to the same group with near-constant-time merge and lookup, using path compression and union by size. - [String Algorithms](https://devpath.abhihyder.com/learn/core-dsa/string-algorithms): Anagram checks with counts, linear-time pattern matching with KMP and rolling hashes, and palindromes by expanding around centers. ## AI & Modern Engineering Vectors, embeddings, similarity search, vector databases, LLMs, and RAG. - [Vectors and Embeddings](https://devpath.abhihyder.com/learn/ai/embeddings): How text becomes a list of numbers, why distance in that space means similarity, and how to compare vectors. - [Similarity Search and ANN Indexes](https://devpath.abhihyder.com/learn/ai/similarity-search-ann): Why exact nearest-neighbour search costs O(n*d), and how IVF clustering and graph indexes like HNSW trade a little recall for a big speedup. - [Vector Databases](https://devpath.abhihyder.com/learn/ai/vector-databases): What a vector database adds beyond an array of embeddings: indexing, metadata filtering, upserts, and persistence. Build a tiny store and compare pgvector, dedicated stores, and FAISS. - [How LLMs Work: Tokens, Context, and Sampling](https://devpath.abhihyder.com/learn/ai/llm-fundamentals): Tokens, the context window, next-token prediction, and how temperature and top-p turn scores into text. Includes why models hallucinate and a sampler built from scratch. - [Prompting and Structured Output](https://devpath.abhihyder.com/learn/ai/prompting-and-structured-output): Prompt anatomy, few-shot examples, and how to get reliable JSON from a model: validate every response and retry with the error fed back. Built against a fake llm so it runs offline. - [RAG: Chunking and Retrieval](https://devpath.abhihyder.com/learn/ai/rag-chunking-and-retrieval): How to split documents into chunks, why overlap and metadata matter, and how BM25, dense search, reciprocal rank fusion, and reranking combine into strong retrieval. - [The RAG Pipeline End to End](https://devpath.abhihyder.com/learn/ai/rag-pipeline): Ingest, retrieve, augment the prompt, generate, and verify citations: a complete retrieval-augmented generation pipeline you can run offline with stand-ins for the embedding model and the llm. - [Evaluating RAG Systems](https://devpath.abhihyder.com/learn/ai/rag-evaluation): Measure retrieval with recall@k, MRR, and nDCG, check answers for faithfulness, build a golden set, and learn the common RAG failure modes. All metrics implemented from scratch. - [Agents and Tool Use](https://devpath.abhihyder.com/learn/ai/agents-and-tool-use): How a model calls functions through a loop of think, act, observe: tool schemas, argument validation, step limits and other guardrails, built offline with a fake llm and two tools. - [LLMs in Production](https://devpath.abhihyder.com/learn/ai/llm-in-production): Cost and latency, caching, streaming, rate limits with retries and backoff, guardrails, prompt injection basics, and observability, shown with a small gateway you can run offline. ## Systems & CS Fundamentals Caches, concurrency, networking, databases, testing, and design patterns. - [Caches and LRU Eviction](https://devpath.abhihyder.com/learn/systems/caches): Why keeping hot data close makes programs fast, from CPU cache lines to application caches, and how to build an LRU cache with a hash map plus a doubly linked list. - [Processes, Threads, and Concurrency](https://devpath.abhihyder.com/learn/systems/processes-and-threads): Processes versus threads, how race conditions lose updates, how locks fix them, how deadlock happens, and how an event loop gets concurrency from a single thread. - [Networking Basics: TCP/IP, DNS, HTTP, TLS](https://devpath.abhihyder.com/learn/systems/networking-basics): How a request travels from a URL to a server: layers, DNS, TCP, TLS, and the exact anatomy of HTTP messages and status codes, with a hand-built parser. - [Databases and SQL](https://devpath.abhihyder.com/learn/systems/databases-and-sql): The relational model, tables, keys, SELECT, JOIN, GROUP BY, and normalization, with a runnable SQLite example and a hand-built join and group-by. - [Indexes, Query Plans, and Transactions](https://devpath.abhihyder.com/learn/systems/indexes-and-transactions): How B-tree indexes turn scans into lookups, how to read EXPLAIN output, and what ACID and isolation levels guarantee, with a runnable SQLite demo. - [Testing: Unit, Integration, and Test Doubles](https://devpath.abhihyder.com/learn/systems/testing): What good tests look like, the test pyramid, unit versus integration tests, stubs, fakes and spies, and a TDD loop, shown with unittest and node:assert. - [Design Patterns That Actually Get Used](https://devpath.abhihyder.com/learn/systems/design-patterns): Strategy, observer, factory, and decorator in a few lines each, plus why singletons deserve suspicion, and how to tell when a pattern helps instead of over-engineering. - [Git: The Commit Graph, Branches, Merge, and Rebase](https://devpath.abhihyder.com/learn/systems/git): Git as a graph of hash-linked commits, branches as movable pointers, merge versus rebase, and the recovery commands (reflog, reset, revert) that save your work. ## System Design Scalability building blocks and how to design large systems in an interview. - [A Framework for System Design](https://devpath.abhihyder.com/learn/system-design/system-design-approach): A repeatable way to attack open-ended design problems: requirements, back-of-envelope estimates, API, data model, high-level design, deep dives, and trade-offs. - [Load Balancing and Scaling](https://devpath.abhihyder.com/learn/system-design/load-balancing-and-scaling): Vertical versus horizontal scaling, why stateless services scale easily, and how round-robin, least-connections, and consistent hashing spread traffic. - [Caching Strategies](https://devpath.abhihyder.com/learn/system-design/caching-strategies): Cache-aside, write-through, and write-back patterns, TTLs, invalidation, and how to stop a cache stampede with request coalescing. - [Databases at Scale](https://devpath.abhihyder.com/learn/system-design/databases-at-scale): Replication for reads and availability, sharding for size, consistency and CAP in plain terms, choosing SQL or NoSQL, and a hash-based shard router with fixed slots. - [Message Queues and Pub/Sub](https://devpath.abhihyder.com/learn/system-design/message-queues): Decouple services with queues and pub/sub, understand at-least-once delivery, make consumers idempotent, and apply backpressure and dead-letter queues. - [Design a URL Shortener](https://devpath.abhihyder.com/learn/system-design/design-url-shortener): A full worked design: requirements, estimates, API, data model, base62 id encoding, redirect path, caching, scaling, and trade-offs such as 301 versus 302. - [Design a Rate Limiter](https://devpath.abhihyder.com/learn/system-design/design-rate-limiter): Compare fixed window, sliding window, and token bucket algorithms, implement two with an injected clock, and design where limits live in a distributed system. ## Interview & Career Interview process, behavioral prep, resume, and your first months on the job. - [How the Software Interview Process Works](https://devpath.abhihyder.com/learn/career/interview-process): The typical stages from application to offer, what each stage tests, how to prepare for each, and a simple weekly study plan you can adapt. - [Solving Coding Problems Under Pressure](https://devpath.abhihyder.com/learn/career/solving-coding-problems): A repeatable method for interview problems: clarify, work an example, state brute force, optimize, code, and test. Worked end to end on a real problem. - [Behavioral Interviews and the STAR Method](https://devpath.abhihyder.com/learn/career/behavioral-interviews): How to prepare specific, honest stories about teamwork, conflict, failure, and ownership, using the STAR structure with a worked example and a story bank. - [Resume and Portfolio](https://devpath.abhihyder.com/learn/career/resume-and-portfolio): Write resume bullets that show impact, structure a one-page resume, and build a small portfolio and online presence that a hiring manager can evaluate in minutes. - [Succeeding in Your First Engineering Job](https://devpath.abhihyder.com/learn/career/first-job): How to ramp up in your first months: a 30-60-90 day plan, asking good questions, working with code review, communicating status, and growing steadily. ## Optional - [Sitemap](https://devpath.abhihyder.com/sitemap.xml) - [Full lesson text](https://devpath.abhihyder.com/llms-full.txt)