Engineering Fundamentals

This set of notes covers everything from how computers operate to how software goes live, and finally delves into models, retrieval, and Agents. The content is organized according to the relationships between questions: first establishing fundamental concepts, then learning development tools, browsers, back-end, data, architecture, deployment, and engineering literacy, and ultimately understanding model systems.

These topics are not separated into another set under “AI applications.” The people writing code or the tools used may change, but the constraints of requirements, interfaces, data, concurrency, permissions, and delivery remain the same. Models also run on operating systems, receive requests via HTTP, store state in databases, rely on caches, queues, and rate limiting to handle traffic, and still require testing, monitoring, rollback, and permission checks. Whether code is written by humans or generated by tools only changes the method and speed of implementation, not these fundamental issues.

What This Set of Notes Aims to Solve

When learning technology, two types of gaps most commonly appear:

1. Only knowing how to use frameworks, but not knowing which layer to investigate when encountering process, network, database, or deployment issues.
2. Memorizing a large number of terms without connecting the concepts into a comprehensible, narratable chain.

These notes aim to unfold each page in roughly the same order:

What is this thing?
    ↓
Why does it exist, and what problem does it solve?
    ↓
Its position in the entire link
    ↓
Key Mechanisms and Common Trade-offs
    ↓
How to judge and verify when an error occurs

I will not keep product advertisements, repeated instructions, animated demonstrations, or course-style padding just to appear complete; nor will I provide only a summary table of conclusions. When a concept appears for the first time, it will be explained before moving on to its usage.

Chapter Map

Chapter	Theme	Main Content
1	Computer Systems	Hardware, Operating System, Coding, Networks, Data Structures, Languages and Compilation
2	Development Tools	Shell, PATH, Dependencies, Ports, SSH, Git, IDE, Debugging, Regular Expressions
3	Browser and Frontend	HTML/CSS, JavaScript, TypeScript, Rendering, Frameworks, State, Build, Performance
4	Servers and Backend	HTTP, API, Authentication, Concurrency, Caching, Queues, Languages, Layering and Project Structure
5	Data	Databases, SQL, Indexes, Transactions, Data Models, Metrics, Experiments, and Governance
6	Architecture and System Design	Distributed Systems, CAP, Consistency, High Availability, Microservices, and Capacity Estimation
7	Infrastructure and Operations	Linux, Containers, Kubernetes, CI/CD, Networking, Cloud, Security, Observability
8	Model Systems	Neural Networks, Transformer, Multimodal, RAG, Agent, Model Deployment and Evaluation
9	Engineering Literacy	Code quality, refactoring, testing, design patterns, security, licensing, technology selection, and writing

First, look at the complete chain

If you want to first establish an overall framework, you can read From Requirements to Stable Operation: The Engineering Panorama. It uses a ‘learning resource collection’ case to link environment, browser, backend, data, architecture, deployment, models, and project delivery into the same request chain, and provides interfaces, table structures, fault analysis, and test examples. After reading it, going back to each chapter to supplement concepts will make it easier to understand where each piece of knowledge fits within the system.

Recommended Reading Order

If it is the first time systematically building a foundation, read in the order 1 → 2 → 3 → 4 → 5 → 6 → 7 → 9 → 8. First, understand how the program runs, how modifications enter the version control, how requests pass through the frontend and backend, and how data is stored, then understand failures and engineering constraints as the service grows, and finally move on to models and agents. The chapter on models is placed at the end, not because it is unimportant, but because it uses all the previous layers at the same time.

If the current goal is to build a complete application, you can start from Chapter 2, complete the backend, database, deployment, and testing, and then move on to the frontend and model. When encountering problems, return to the corresponding layer to review the concepts; there is no need to read everything at once.

If your current goal is to develop a model or Agent application, don’t skip directly to Chapter 8. At the very least, first master HTTP, processes and threads, database transactions, caching, queues, containers, and basic testing. Otherwise, it is easy to confuse issues like ‘prompt not written well,’ ‘tool timeout,’ ‘context overflow,’ and ‘database lock waiting’ as the same problem.

How to use each page

• For the first round, read the main text without rushing to memorize the tables; you just need to be able to paraphrase the inputs, outputs, states, and failure modes in your own words.
• On the second pass, look at examples and trade-offs, and ask yourself, ‘What would happen if traffic increased tenfold, dependencies slowed down, or data became inconsistent?’
• Treat relevant pages as checklists when working on a project, not as answer banks. First write down the current constraints, then choose the tools.
• When reviewing, only look at the titles and the conclusions at the beginning of each section, and return to the main text when you encounter parts that are unclear.

Note Boundaries

This is a personal study note, not official documentation, and it does not aim to cover the latest APIs of any technology. Versions may change, but concepts and methods of judgment are more worth keeping. Code examples are kept as short as possible, with the focus on showing how data flows, where the boundaries are, and how failures might occur.

Some of the content’s structure and themes come from open course materials, with copyright and modification instructions concentrated on the Sources and Copyright page. The main text only discusses the technology itself and does not repeat source statements in each article.

Should be able to do after learning

1. When looking at an application, you can illustrate the relationships between the browser, network, services, database, cache, and deployment environment.
2. When encountering ‘works locally but fails online,’ one can narrow down the scope step by step according to environment, network, permissions, configuration, resources, and code.
3. Can design a set of interfaces and table structures, and explain pagination, idempotency, authentication, indexes, and transaction boundaries.
4. Able to determine whether a performance issue occurs in loading, computation, memory, disk, network, or queuing.
5. Able to set up logs, metrics, traces, alerts, and rollback plans for services.
6. Able to understand the complete chain of models, RAG, and Agent systems, and know how to verify them, rather than just looking at the demo results.