程序员知识栈/开发指南

有时候开发难度不在于编码技术，而在于项目认知。日常被搭环境弄崩溃了，干脆在这里做个备忘录。

1. 什么是”环境”

核心概念解释

• 开发环境（Development Environment）：指开发者用来编写、测试、调试代码的软硬件组合，包括操作系统、编译器、解释器、IDE、依赖库等。
• 运行环境（Runtime Environment）：指程序实际运行时所需的系统和依赖配置，通常与开发环境有所区别。
• 环境变量（Environment Variable）：操作系统用于配置系统行为的变量，如PATH、JAVA_HOME等，影响程序查找可执行文件和依赖库的路径。

开发环境是程序员工作的基础平台，包括：

1.1 操作系统环境

• Windows环境配置（Windows是最常见的桌面操作系统，适合大多数办公和开发场景）
  • 环境变量设置（PATH、JAVA_HOME等，环境变量是系统用来告诉程序去哪里找文件或工具的设置）
  • 系统服务配置（MySQL、Redis等，服务是一直在后台运行、为你提供功能的程序）
  • 权限管理（UAC、防火墙，权限管理决定谁能做什么，比如用管理员权限安装软件）
• Linux环境配置（Linux是开源的操作系统，常用于服务器和开发环境）
  • 包管理器使用（apt、yum，包管理器帮你自动安装和管理软件）
  • 服务管理（systemd，systemd是Linux下常用的服务管理工具）
  • 用户权限（sudo、chmod，sudo让你临时获得管理员权限，chmod用来修改文件权限）
• macOS环境配置（macOS是苹果电脑的操作系统，适合开发和设计）
  • Homebrew包管理（Homebrew是macOS下最流行的包管理器）
  • 开发工具链配置（比如Xcode、命令行工具）
  • 权限管理（和Linux类似，也有sudo等命令）

1.2 编程语言环境

• Python环境
  • 虚拟环境（venv、conda，虚拟环境为每个项目单独准备一套依赖，互不影响）
  • 包管理（pip、poetry，pip是Python最常用的包管理工具）
  • 版本管理（pyenv，pyenv可以让你在一台电脑上切换不同版本的Python）
• Java环境
  • JDK安装与配置（JDK是Java开发工具包，包含编译和运行Java程序需要的东西）
  • Maven/Gradle构建工具（自动帮你编译、打包、测试代码的软件）
  • JVM参数调优（JVM是Java虚拟机，可以通过参数优化性能）
• C/C++环境
  • 编译器配置（gcc、clang，编译器把源代码变成可执行程序）
  • 构建系统（CMake、Make，自动生成和管理编译流程的工具）
  • 调试工具（gdb，gdb是C/C++程序常用的调试工具）

1.3 开发工具环境

• IDE配置（IDE是集成开发环境，比如VS Code、IntelliJ IDEA，集成了代码编辑、调试、构建等功能）
  • VS Code插件与配置（插件可以给IDE加新功能，比如代码高亮、自动补全）
  • IntelliJ IDEA配置
  • Eclipse配置
• 编辑器配置
  • Vim/Emacs配置（Vim和Emacs是经典的文本编辑器，适合喜欢键盘操作的开发者）
  • 代码格式化工具（自动帮你整理代码风格）
  • 语法检查工具（检查代码是否有语法错误）
• 终端工具
  • Shell配置（bash、zsh，Shell是命令行解释器，帮你执行输入的命令）
  • 终端复用器（tmux，tmux让你在一个窗口里开多个命令行）
  • SSH配置（SSH让你远程登录到别的电脑）

1.4 运行环境

• Docker环境（Docker是用来打包和隔离应用的工具，让程序在任何地方都能跑起来）
  • 镜像构建（镜像是Docker里的”程序快照”，包含运行所需的一切）
  • 容器编排（容器是基于镜像运行的独立环境，编排是管理多个容器的运行）
  • 网络配置
• 虚拟机环境（虚拟机是在一台电脑上模拟另一台电脑的软件，比如VirtualBox）
  • VirtualBox配置
  • VMware配置
  • 快照管理
• 云环境（云环境是把服务器、存储等资源放在互联网上，比如AWS、Azure）
  • AWS配置
  • Azure配置
  • GCP配置

2. 什么是”工具链”

核心概念解释

• 工具链（Toolchain）：一组协同工作的开发工具集合，通常包括编译器、构建系统、调试器、打包工具等，用于实现从源代码到可执行程序的全过程。
• 构建系统（Build System）：自动化管理代码编译、链接、打包等流程的工具，如CMake、Make、Gradle等。
• 持续集成（CI, Continuous Integration）：通过自动化工具持续地将代码集成到主分支，及时发现和解决集成问题。

工具链是开发过程中使用的各种工具集合：

2.1 构建工具

• CMake（CMake是跨平台的自动化构建系统，能生成各种编译器的工程文件）
  • 基本语法（CMake脚本用来描述项目结构和依赖）
  • 模块化构建（将项目拆分为多个模块，便于管理）
  • 依赖管理（自动查找和链接第三方库）
  • 跨平台配置（同一套脚本可在Windows、Linux、macOS下使用）
• Make（Make是经典的自动化构建工具，常用于Unix/Linux系统）
  • Makefile编写（Makefile是告诉Make如何编译项目的脚本文件）
  • 自动化构建（只需一条命令即可完成全部编译流程）
  • 依赖关系（自动判断哪些文件需要重新编译）
• Gradle（Gradle是现代的构建工具，常用于Java、Android项目）
  • 构建脚本（用Groovy或Kotlin编写，描述项目构建流程）
  • 插件开发（可扩展功能，适应不同项目需求）
  • 多项目构建（支持大型项目的分模块管理）

2.2 版本控制工具

• Git（Git是最流行的分布式版本控制系统，能记录每次代码修改）
  • 基本命令（如git add、git commit、git push，分别用于添加、提交、推送代码）
  • 分支管理（分支让你可以同时开发多个功能，互不影响）
  • 工作流（如Git Flow、GitHub Flow，规范团队协作方式）
  • 冲突解决（当多人修改同一文件时，Git会提示冲突，需要手动合并）
• SVN（SVN是集中式版本控制工具，适合小型团队）
  • 基本操作（如checkout、commit、update，分别用于检出、提交、更新代码）
  • 分支管理（支持分支和标签，但操作方式与Git不同）
  • 权限控制（可细致设置不同用户的访问权限）

2.3 调试工具

• GDB（GDB是C/C++程序常用的调试器，可以设置断点、单步执行、查看变量）
  • 断点设置（让程序在指定位置暂停，方便检查问题）
  • 变量查看（随时查看和修改变量的值）
  • 堆栈跟踪（分析程序崩溃时的调用链）
• LLDB（LLDB是LLVM项目的调试器，适用于C/C++/Swift等语言）
  • 基本命令（与GDB类似，支持断点、单步、变量查看）
  • 内存调试（可检查内存分配和访问）
  • 多线程调试（支持调试多线程程序）
• 浏览器调试工具（如Chrome DevTools，内置于浏览器，用于调试网页）
  • 元素检查（查看和修改网页结构和样式）
  • 网络分析（监控网页的网络请求）
  • 控制台（输出日志、执行JS代码）

2.4 性能分析工具

• Profiler（Profiler是分析程序运行速度和资源消耗的工具）
  • CPU分析（找出耗时最多的函数）
  • 内存分析（检测内存泄漏和高占用）
  • I/O分析（分析磁盘和网络读写性能）
• Memory Analyzer（专门用于分析内存使用情况的工具）
  • 内存泄漏检测（找出未释放的内存）
  • 堆分析（查看内存分配情况）
  • 对象引用分析（分析对象之间的引用关系）
• 网络分析工具（如Wireshark，抓包工具，用于分析网络通信）
  • Fiddler/Charles（常用于调试HTTP请求和响应）

3. 什么是”依赖”

核心概念解释

• 依赖（Dependency）：指一个项目在编译、运行或测试时所需的外部库、框架或工具。
• 依赖管理（Dependency Management）：通过工具（如pip、npm、vcpkg等）自动化管理依赖的安装、升级和版本控制。
• 依赖冲突（Dependency Conflict）：不同依赖之间版本不兼容或功能重叠导致的问题。

依赖是指项目运行所必需的第三方库和组件：

3.1 系统依赖

• 操作系统库（如动态链接库.so/.dll，程序运行时才加载的库；静态链接库.a/.lib，编译时打包进程序）
  • 动态链接库（.so、.dll，节省内存、便于升级）
  • 静态链接库（.a、.lib，部署简单、体积较大）
  • 系统API（操作系统提供的功能接口，如文件操作、网络通信）
• 运行时环境（如JRE、Python解释器、Node.js，提供程序运行所需的基础环境）

3.2 语言依赖

• 标准库（每种编程语言自带的常用功能集合，如C++ STL、Java标准库、Python标准库）
• 框架（帮你快速开发应用的”半成品”代码，如Spring、Django、React）

3.3 第三方库依赖

• 开源库（公开源代码、免费使用的库，需注意许可证）
  • 版本选择（选择合适的版本，兼容项目需求）
  • 许可证检查（了解库的使用和分发规则）
  • 安全审计（检查库是否有安全漏洞）
• 商业库（需要购买授权才能用的库）
  • 授权管理（管理许可证和使用权限）
  • 更新策略（定期检查和升级库版本）
  • 技术支持（遇到问题可获得厂商帮助）

3.4 开发依赖

• 测试框架（如JUnit、pytest、Mocha，帮你自动化测试代码）
• 文档工具（如Doxygen、Sphinx、JSDoc，自动生成项目文档）
• 代码质量工具（如SonarQube、ESLint、Pylint，检查代码规范和潜在问题）

4. 第三方库的用法

核心概念解释

• 第三方库（Third-party Library）：由外部组织或个人开发、维护的可复用代码库，非项目自身代码。
• 依赖注入（Dependency Injection）：一种设计模式，通过外部传递依赖对象，降低模块间耦合度。
• 版本锁定（Version Pinning）：指定依赖库的精确版本，避免因自动升级导致的不兼容问题。

使用第三方库的最佳实践：

4.1 版本管理

• 版本锁定（指定依赖库的精确版本，避免因自动升级导致的不兼容问题）
  • 精确版本号（如1.2.3，确保每次安装的都是同一个版本）
  • 版本范围（允许一定范围内的版本升级）
  • 版本更新策略（定期检查和升级依赖，保证安全和兼容）
• 依赖冲突解决（当不同库需要的依赖版本不一致时，需要手动解决）
  • 依赖树分析（查看所有依赖的关系和版本）
  • 版本兼容性（确保所有依赖能一起正常工作）
  • 冲突解决策略（如强制指定某个版本或排除某些依赖）

4.2 依赖注入

• 设计模式（常用的代码结构方案，如控制反转、依赖注入、服务定位器）
  • 控制反转（IoC，程序不主动创建依赖，而是由外部传入）
  • 依赖注入（DI，通过构造函数、属性或方法把依赖传给对象）
  • 服务定位器（通过一个统一的”服务工厂”获取依赖）
• 实现方式
  • 构造函数注入（依赖通过构造函数传入）
  • 属性注入（依赖通过对象属性传入）
  • 方法注入（依赖通过方法参数传入）

4.3 错误处理

• 异常处理（程序运行出错时的应对方式）
  • 异常类型（如语法错误、运行时错误、逻辑错误）
  • 异常传播（错误可以被捕获、传递或重新抛出）
  • 异常恢复（通过catch等机制恢复程序运行）
• 错误码处理（用数字或字符串表示不同的错误类型）
  • 错误码定义（统一管理所有错误类型）
  • 错误信息（为每个错误码配上易懂的说明）
  • 错误处理策略（如重试、忽略、终止程序）

4.4 性能优化

• 资源管理（合理使用和释放内存、文件、网络等资源）
  • 内存管理（防止内存泄漏和过度占用）
  • 连接池（复用数据库或网络连接，提升性能）
  • 缓存策略（用缓存减少重复计算或请求）
• 并发处理（让程序能同时做多件事）
  • 线程安全（多线程访问同一资源时不会出错）
  • 异步操作（不等待任务完成，先做别的事）
  • 并发控制（如锁、信号量，防止资源冲突）

5. 什么是GIT

核心概念解释

• 版本控制系统（VCS, Version Control System）：用于跟踪文件变化、协作开发和管理历史记录的工具。
• 分支（Branch）：在同一代码库中并行开发不同功能或修复的独立线索。
• 合并（Merge）：将不同分支的更改整合到一起，解决冲突后形成统一代码基线。

Git是现代软件开发的核心工具：

5.1 版本控制

• 基本概念
  • 仓库（Repository，存放所有代码和历史记录的地方）
  • 提交（Commit，每次保存代码的快照）
  • 分支（Branch，开发新功能或修复bug的独立线索）
• 工作流程
  • 暂存区（保存准备提交的更改）
  • 工作区（你正在编辑的本地文件夹）
  • 版本库（保存所有历史记录的数据库）

5.2 分支管理

• 分支策略（如Git Flow、GitHub Flow、Trunk Based Development，规范团队如何使用分支）
• 分支操作
  • 创建分支（新建一个开发线索）
  • 合并分支（把不同分支的更改合并到一起）
  • 删除分支（清理不再需要的分支）

5.3 团队协作

• 远程仓库（如GitHub、GitLab，团队成员共享代码的平台）
  • 添加远程（把本地仓库和远程仓库关联）
  • 推送代码（把本地更改上传到远程）
  • 拉取代码（从远程获取最新代码）
• 代码审查
  • Pull Request（提交合并请求，方便团队讨论和审核）
  • Code Review（团队成员互相检查代码）
  • 代码合并（通过审核后把更改合并到主分支）

5.4 高级特性

• 子模块（在一个仓库里嵌入另一个仓库，方便复用）
  • 添加子模块（引入外部项目）
  • 更新子模块（同步外部项目的最新代码）
  • 删除子模块（移除不再需要的外部项目）
• 钩子脚本（自动执行的脚本，如提交前检查代码格式）
  • 预提交钩子（commit前自动检查或格式化代码）
  • 提交消息钩子（规范提交说明）
  • 推送钩子（push前自动运行测试等）

6. IDE的用法

核心概念解释

• IDE（Integrated Development Environment）：集成代码编辑、调试、构建、测试等功能的开发工具，如VS Code、IntelliJ IDEA等。
• 代码补全（Code Completion）：IDE根据上下文自动提示变量、方法、类名等，提高开发效率。
• 重构（Refactoring）：在不改变代码外部行为的前提下，优化代码结构和可读性。

集成开发环境的使用技巧：

6.1 代码补全

• 智能提示（IDE根据你输入的内容自动补全变量、方法、类名等）
  • 类型提示（显示变量或函数的类型信息）
  • 参数提示（输入函数时自动显示参数列表）
  • 文档提示（显示函数或类的说明文档）
• 代码模板（预设的代码片段，能快速插入常用结构）
  • 自定义模板（自己编写常用代码片段）
  • 代码片段（内置或第三方提供的快捷代码）
  • 快捷键（通过组合键快速插入或操作代码）

6.2 调试功能

• 断点调试（在代码某一行设置断点，程序运行到这里会暂停）
  • 条件断点（只有满足特定条件时才暂停）
  • 日志断点（断点时自动输出日志信息）
  • 异常断点（遇到异常时自动暂停）
• 变量查看（调试时可以实时查看和修改变量的值）
  • 变量监视（持续观察某个变量的变化）
  • 表达式求值（临时计算某个表达式的值）
  • 内存查看（直接查看内存中的数据内容）

6.3 重构工具

• 代码重构（在不改变功能的前提下优化代码结构）
  • 重命名（批量修改变量、函数、类名等）
  • 提取方法（把重复或复杂的代码提取成独立函数）
  • 内联方法（把简单的函数直接展开到调用处）
• 代码分析（自动检查代码中的潜在问题）
  • 代码检查（查找语法错误、风格问题等）
  • 复杂度分析（评估代码的复杂程度）
  • 依赖分析（分析模块或类之间的依赖关系）

6.4 插件扩展

• 插件管理（安装、配置和更新IDE插件）
  • 安装插件（从插件市场下载安装新功能）
  • 配置插件（根据需要调整插件设置）
  • 更新插件（保持插件为最新版本）
• 自定义功能（根据个人或团队需求扩展IDE）
  • 自定义命令（添加快捷操作或脚本）
  • 自定义视图（调整界面布局或显示内容）
  • 自定义工具（集成第三方工具或服务）

7. 设计模式

核心概念解释

• 设计模式（Design Pattern）：总结自优秀软件工程实践的通用解决方案，用于应对常见设计问题。
• 单例模式（Singleton）：保证一个类只有一个实例，并提供全局访问点。
• 工厂模式（Factory）：通过工厂方法创建对象，解耦对象创建与使用。

常见设计模式的应用：

7.1 创建型模式

• 工厂模式（通过工厂方法创建对象，解耦对象创建与使用）
  • 简单工厂（用一个工厂类根据参数创建不同对象）
  • 工厂方法（每个子类负责创建自己的对象）
  • 抽象工厂（提供一组相关对象的创建接口）
• 单例模式（保证一个类只有一个实例，并提供全局访问点）
  • 饿汉式（程序启动时就创建实例）
  • 懒汉式（用到时才创建实例）
  • 双重检查（多线程下安全地创建单例）

7.2 结构型模式

• 适配器模式（让原本不兼容的接口可以一起工作）
  • 类适配器（通过继承实现适配）
  • 对象适配器（通过组合实现适配）
  • 接口适配器（为接口提供默认实现）
• 装饰器模式（动态地给对象添加新功能）
  • 动态装饰（运行时添加功能）
  • 静态装饰（编译时确定功能）
  • 组合装饰（多个装饰器叠加使用）

7.3 行为型模式

• 观察者模式（对象间一对多依赖，状态变化时自动通知所有观察者）
  • 推模式（被观察者主动推送消息）
  • 拉模式（观察者主动拉取消息）
  • 事件驱动（通过事件机制实现通知）
• 策略模式（将算法封装成独立的策略类，方便切换和扩展）
  • 算法封装（每种策略实现不同算法）
  • 策略选择（运行时选择合适的策略）
  • 动态切换（根据需要随时更换策略）

7.4 架构模式

• MVC模式（Model-View-Controller，分离数据、界面和逻辑）
  • 模型层（Model，负责数据和业务逻辑）
  • 视图层（View，负责界面显示）
  • 控制器层（Controller，负责协调模型和视图）
• MVVM模式（Model-View-ViewModel，适合前端开发的数据绑定架构）
  • 数据绑定（自动同步界面和数据）
  • 视图模型（ViewModel，处理界面逻辑）
  • 命令模式（用命令对象封装用户操作）

8. 标准和规范

核心概念解释

• 代码规范（Coding Standard）：统一团队代码风格和格式的规则，提升代码可读性和可维护性。
• 文档规范（Documentation Standard）：规定注释、API文档等的书写格式和内容要求。
• 安全规范（Security Standard）：确保代码和系统安全的最佳实践和要求。

开发中的标准和规范：

8.1 代码规范

• 命名规范（统一变量、函数、类等的命名风格，便于阅读和维护）
  • 类命名（通常用大驼峰命名法，如MyClass）
  • 方法命名（常用小驼峰命名法，如doSomething）
  • 变量命名（简洁明了，表达含义）
• 格式规范（统一代码缩进、空格、换行等格式）
  • 缩进规则（如每层缩进4个空格）
  • 空格规则（如运算符两边加空格）
  • 换行规则（每行不超过80字符，便于阅读）

8.2 文档规范

• 注释规范（为代码添加说明，便于他人理解）
  • 类注释（说明类的作用和用法）
  • 方法注释（说明方法的功能、参数和返回值）
  • 行注释（对关键代码行做简要说明）
• API文档（描述接口的功能和用法）
  • 接口描述（说明接口的用途）
  • 参数说明（列出每个参数的含义和类型）
  • 返回值说明（说明返回的数据类型和含义）

8.3 安全规范

• 加密规范（保护数据安全的规则）
  • 对称加密（加密和解密用同一个密钥，如AES）
  • 非对称加密（加密和解密用不同密钥，如RSA）
  • 哈希算法（将数据变成定长”指纹”，如SHA256）
• 认证规范（验证用户身份的规则）
  • 身份认证（如用户名密码、短信验证码）
  • 授权控制（限制用户能访问的资源）
  • 会话管理（管理用户登录状态）

8.4 测试规范

• 单元测试（测试最小功能单元，如一个函数）
  • 测试用例（具体的测试场景和输入输出）
  • 测试覆盖率（代码被测试的比例）
  • 测试报告（记录测试结果）
• 集成测试（测试多个模块协同工作）
  • 接口测试（测试模块间的数据交互）
  • 性能测试（测试系统在高负载下的表现）
  • 压力测试（测试系统极限承载能力）

9. SDK开发和对接

核心概念解释

• SDK（Software Development Kit）：为开发者提供的工具包，包含API、文档、示例代码等，便于集成特定功能。
• API（Application Programming Interface）：应用程序编程接口，定义不同软件组件之间的交互方式。
• 兼容性（Compatibility）：指新旧版本之间接口、数据、行为的一致性，避免升级带来破坏性变更。

SDK开发的关键点：

9.1 API设计

• 接口定义（明确每个API的功能和用法）
  • 方法签名（方法名、参数和返回值的定义）
  • 参数设计（参数类型、必选/可选、默认值等）
  • 返回值设计（返回数据的结构和含义）
• 错误处理
  • 异常定义（定义API可能抛出的异常类型）
  • 错误码（用数字或字符串标识不同错误）
  • 错误信息（为错误码配上易懂的说明）

9.2 版本兼容

• 向后兼容（新版本能兼容老版本的接口和数据）
  • 接口兼容（不随意删除或修改已有接口）
  • 数据兼容（新旧数据格式都能识别）
  • 行为兼容（保持接口行为一致）
• 版本管理
  • 版本号规则（如主版本.次版本.修订号）
  • 版本发布（发布新版本时的流程）
  • 版本回滚（新版本有问题时能快速恢复旧版本）

9.3 文档编写

• 使用说明（帮助用户快速上手）
  • 快速开始（最简单的使用流程）
  • 示例代码（常见用法的代码示例）
  • 常见问题（FAQ，解答常见疑问）
• API文档
  • 接口说明（详细描述每个API的功能）
  • 参数说明（列出所有参数及其含义）
  • 返回值说明（说明API的输出结果）

9.4 测试验证

• 单元测试（测试每个API的基本功能）
  • 接口测试（验证API输入输出是否正确）
  • 边界测试（测试极端或异常输入）
  • 异常测试（测试错误处理是否合理）
• 集成测试（测试API与其他模块的协作）
  • 功能测试（验证整体功能是否正常）
  • 性能测试（测试API响应速度和并发能力）
  • 兼容性测试（测试不同环境下的表现）

10. 不同OS的编码路径

核心概念解释

• 跨平台（Cross-platform）：指软件能够在不同操作系统（如Windows、Linux、macOS）上运行。
• 路径分隔符（Path Separator）：不同操作系统用于分隔文件路径的符号，如Windows为\\，Unix为/。
• 条件编译（Conditional Compilation）：根据目标平台选择性编译不同代码片段。

跨平台开发注意事项：

10.1 文件路径

• 路径分隔符（不同操作系统用于分隔文件路径的符号，Windows用\，Unix用/）
• 路径处理（如何正确拼接、解析和规范化文件路径）
  • 相对路径（相对于当前目录的路径，如./data）
  • 绝对路径（从根目录开始的完整路径，如C:\Users\）
  • 路径规范化（自动去除多余的/或\，统一格式）

10.2 字符编码

• 编码标准（不同的字符编码方式，如UTF-8、GBK、ASCII）
• 编码转换（在不同编码之间转换，防止乱码）
  • 文件编码（保存文件时选择的编码格式）
  • 网络传输（数据在网络上传输时的编码）
  • 数据库存储（数据库保存字符串时的编码设置）

10.3 系统API

• 平台差异（不同操作系统的API和行为可能不同）
  • 文件操作（如文件读写、权限设置）
  • 进程管理（如启动、终止进程）
  • 网络通信（如Socket编程）
• 兼容处理（让代码能在多平台上运行）
  • 条件编译（用宏或条件语句区分不同平台的代码）
  • 抽象层（封装平台相关的实现，提供统一接口）
  • 适配器模式（用适配器类屏蔽平台差异）

10.4 编译选项

• 条件编译（根据目标平台选择性编译不同代码片段）
  • 预处理器（如C/C++中的#ifdef、#endif）
  • 宏定义（用#define定义常量或条件）
  • 编译选项（编译器参数，控制编译行为）
• 交叉编译（在一种平台上为另一种平台生成可执行文件）
  • 工具链配置（配置交叉编译所需的编译器和库）
  • 目标平台（指定编译输出的目标系统）
  • 依赖管理（确保目标平台的依赖都已准备好）

11. 计算机原理

核心概念解释

• 操作系统（Operating System）：管理计算机硬件和软件资源的系统软件。
• 网络协议（Network Protocol）：定义网络通信规则的标准，如TCP/IP、HTTP等。
• 数据结构（Data Structure）：组织和存储数据的方式，如数组、链表、树、图等。
• 算法（Algorithm）：解决特定问题的步骤和方法。

基础计算机知识：

11.1 操作系统原理

• 进程管理（操作系统如何调度和管理运行的程序）
  • 进程调度（决定哪个程序先运行）
  • 进程通信（不同进程之间的数据交换方式）
  • 死锁处理（防止程序互相等待导致卡死）
• 内存管理（操作系统如何分配和回收内存）
  • 虚拟内存（让每个程序都觉得自己有独立的内存空间）
  • 页面置换（内存不够时，把暂时不用的数据换到硬盘）
  • 内存分配（分配和释放内存的机制）

11.2 网络协议

• TCP/IP协议（三次握手、四次挥手，保证数据可靠传输）
• HTTP协议（Web通信的基础协议，包括请求方法、状态码、头部字段）
• 网络编程（用代码实现网络通信）
  • Socket编程（底层网络通信接口，支持TCP/UDP）
    • TCP/UDP通信（TCP可靠、UDP快速）
    • 多线程服务器（同时处理多个客户端连接）
    • 异步IO模型（不阻塞主线程，提高效率）
  • 网络框架（如Netty、Boost.Asio、libuv，简化网络编程）
  • 协议设计（自定义消息格式和通信规则）
    • 消息格式（定义数据结构和编码方式）
    • 序列化/反序列化（数据和对象的互相转换）
    • 协议版本控制（支持协议升级和兼容）
  • 网络安全（SSL/TLS加密通信，证书管理）
  • 性能优化（如连接池、负载均衡、缓存策略）
  • 监控与调试（抓包、性能分析、日志记录）

11.3 数据结构

• 线性结构（数据按顺序排列，如数组、链表、栈、队列）
• 非线性结构（数据有层级或网状关系，如树、图、哈希表）

11.4 算法基础

• 排序算法（如冒泡排序、快速排序、归并排序，按特定规则排列数据）
• 查找算法（如顺序查找、二分查找、哈希查找，快速定位数据）

12. 什么是”敏捷开发”

核心概念解释

• 敏捷开发（Agile Development）：强调快速迭代、持续交付和团队协作的软件开发方法论。
• Scrum：敏捷开发常用框架，强调角色分工、短周期迭代和持续改进。
• 看板（Kanban）：通过可视化任务流和在制品限制，提升团队工作效率。

敏捷开发方法论：

12.1 Scrum框架

• 角色定义（Scrum团队的三种角色）
  • 产品负责人（负责需求和优先级）
  • Scrum Master（负责流程和障碍清除）
  • 开发团队（负责具体开发工作）
• 会议流程（Scrum的核心会议）
  • 每日站会（每天简短同步进展和问题）
  • 迭代计划（规划本次迭代要完成的任务）
  • 回顾会议（总结本次迭代的经验和改进点）

12.2 看板方法

• 工作流（任务从待办到完成的流转过程）
  • 任务看板（用卡片可视化每个任务的状态）
  • 状态流转（任务在不同阶段间移动）
  • 限制在制品（限制同时进行的任务数量，防止过载）
• 可视化（让团队一目了然当前进展）
  • 任务卡片（每个任务一张卡片，包含关键信息）
  • 燃尽图（显示剩余工作量随时间的变化）
  • 累积流图（展示任务在各阶段的分布和变化）

12.3 持续集成

• 构建流程（自动化代码集成和测试的过程）
  • 代码提交（开发者将更改推送到代码库）
  • 自动构建（系统自动编译和打包代码）
  • 自动测试（自动运行测试用例，保证质量）
• 质量保证（确保代码稳定可靠）
  • 代码检查（自动检测代码规范和潜在问题）
  • 测试覆盖（统计代码被测试的比例）
  • 性能测试（检测系统在高负载下的表现）

12.4 持续交付

• 部署流程（自动化将代码发布到生产环境）
  • 自动化部署（用脚本或工具自动完成部署）
  • 环境管理（管理不同的测试、预发布、生产环境）
  • 回滚机制（部署失败时能快速恢复到旧版本）
• 监控告警（实时监控系统状态并及时报警）
  • 系统监控（监控服务器、应用等运行状态）
  • 性能监控（监控响应速度、资源消耗等）
  • 错误监控（自动收集和报告错误信息）

13. 项目管理

核心概念解释

• 需求管理（Requirement Management）：收集、分析、追踪和变更项目需求的全过程。
• 进度控制（Schedule Control）：通过计划、跟踪和调整，确保项目按时完成。
• 风险管理（Risk Management）：识别、评估和应对项目中可能出现的问题。

项目管理的核心要素：

13.1 需求管理

• 需求分析（理解和细化用户需求）
  • 用户故事（用简短描述表达用户需求）
  • 用例分析（分析系统与用户的交互场景）
  • 需求优先级（根据价值和紧急程度排序）
• 变更管理（应对需求变化的流程）
  • 变更控制（规范变更的申请和审批）
  • 影响分析（评估变更对项目的影响）
  • 版本控制（用工具管理不同版本的需求和代码）

13.2 进度控制

• 计划制定（制定详细的项目计划）
  • 任务分解（把大任务拆成小任务）
  • 时间估算（评估每个任务需要的时间）
  • 资源分配（合理安排人力、设备等资源）
• 进度跟踪（实时监控项目进展）
  • 里程碑（设定关键节点，便于检查进度）
  • 进度报告（定期汇报项目状态）
  • 风险预警（提前发现和应对进度风险）

13.3 风险管理

• 风险识别（找出项目可能遇到的问题）
  • 技术风险（技术难题或新技术带来的不确定性）
  • 进度风险（任务延期的可能性）
  • 资源风险（人力、资金、设备等不足）
• 风险应对（制定应对措施）
  • 风险规避（提前消除风险因素）
  • 风险转移（将风险转嫁给第三方，如保险）
  • 风险缓解（降低风险发生的概率或影响）

13.4 团队协作

• 沟通管理（高效的信息交流方式）
  • 会议管理（合理安排和记录会议）
  • 文档共享（用工具共享和协作编辑文档）
  • 即时通讯（用聊天工具快速沟通）
• 知识管理（积累和传承团队经验）
  • 经验总结（定期复盘和总结教训）
  • 最佳实践（整理和推广有效的工作方法）
  • 培训计划（为新成员提供学习资源）

14. 开发最佳实践

14.1 代码质量

• 代码审查（团队成员互相检查代码，提升质量）
  • 审查清单（列出检查要点，防止遗漏）
  • 自动化工具（用软件自动检测代码问题）
  • 团队协作（多人共同参与审查和讨论）
• 代码重构（优化代码结构，提高可读性和可维护性）
  • 重构时机（如功能变更、发现坏味道时）
  • 重构方法（如提取函数、消除重复代码）
  • 测试保障（重构后用测试确保功能不变）
• 技术债务（为赶进度留下的隐患和问题）
  • 债务识别（发现代码中的短板和隐患）
  • 偿还策略（制定计划逐步优化）
  • 预防措施（规范开发流程，减少新债务）

14.2 性能优化

• 代码优化（提升程序运行效率）
  • 算法优化（选择更高效的算法）
  • 数据结构优化（用合适的数据结构存储和处理数据）
  • 内存优化（减少不必要的内存分配和占用）
• 系统优化（提升整体系统性能）
  • 并发优化（合理利用多核CPU）
  • 缓存优化（用缓存减少重复计算和访问）
  • 数据库优化（优化SQL语句和索引）
• 监控分析（实时监控和分析性能指标）
  • 性能指标（如响应时间、吞吐量等）
  • 监控工具（如Prometheus、Grafana，实时展示数据）
  • 分析报告（定期总结和优化建议）

14.3 安全开发

• 安全编码（写代码时注意防范安全风险）
  • 输入验证（检查用户输入是否合法）
  • 输出编码（防止输出内容被恶意利用）
  • 错误处理（不泄露敏感信息）
• 安全测试（主动发现安全漏洞）
  • 渗透测试（模拟黑客攻击，发现弱点）
  • 代码审计（人工或自动检查安全隐患）
  • 漏洞扫描（用工具扫描已知漏洞）
• 安全运维（上线后持续保障安全）
  • 日志审计（记录和分析操作日志）
  • 访问控制（限制系统访问权限）
  • 应急响应（发现安全事件时快速处理）

14.4 持续学习

• 技术学习（不断掌握新知识和技能）
  • 学习路线（规划学习顺序和重点）
  • 学习资源（书籍、课程、社区等）
  • 实践项目（通过实际项目提升能力）
• 知识管理（整理和积累个人或团队知识）
  • 笔记系统（用工具记录和归纳知识点）
  • 知识库（集中存放和共享资料）
  • 经验总结（定期复盘和反思）
• 社区参与（积极参与技术社区）
  • 开源贡献（参与开源项目，提升影响力）
  • 技术分享（写博客、做讲座等）
  • 问题解答（在社区帮助他人解决问题）

15. 开发工具链

15.1 开发工具

• 编辑器（如VS Code、Vim/Emacs、Sublime Text，编写和编辑代码的工具）
• IDE（如IntelliJ IDEA、Eclipse、Visual Studio，集成多种开发功能的环境）
• 终端工具（如iTerm2、Windows Terminal、tmux，命令行操作和多窗口管理）

15.2 构建工具

• 包管理（如npm/yarn、pip/conda、Maven/Gradle，自动下载和管理依赖库）
• 构建系统（如CMake、Make、Bazel，自动化编译和打包项目）
• 容器化（如Docker、Kubernetes、Podman，用容器隔离和部署应用）

15.3 测试工具

• 单元测试（如JUnit、pytest、Mocha，测试最小功能单元）
• 集成测试（如Postman、Selenium、JMeter，测试模块间协作和系统整体功能）
• 性能测试（如Apache Bench、Gatling、Locust，测试系统在高负载下的表现）

15.4 监控工具

• 日志监控（如ELK Stack、Graylog、Splunk，收集和分析日志）
• 性能监控（如Prometheus、Grafana、New Relic，实时监控系统性能）
• 告警系统（如Alertmanager、PagerDuty、OpsGenie，自动通知异常和故障）

16. 开发流程

16.1 需求分析

• 需求收集（通过访谈、调研等方式获取用户需求）
  • 用户访谈（直接与用户交流，了解真实需求）
  • 市场调研（分析市场和竞品，发现机会）
  • 竞品分析（对比同类产品，找出优劣势）
• 需求分析（对收集到的需求进行细化和评估）
  • 功能分解（把大需求拆成小功能）
  • 优先级排序（根据重要性和紧急程度排序）
  • 风险评估（分析需求实现的难度和风险）
• 需求文档（用文档记录和传达需求）
  • 用户故事（简洁描述用户需求和目标）
  • 用例图（用图形展示系统和用户的交互）
  • 原型设计（用原型工具画出界面草图）

16.2 设计阶段

• 架构设计（确定系统整体结构和模块划分）
  • 系统架构（整体框架和技术选型）
  • 模块划分（把系统拆分为独立模块）
  • 接口设计（定义模块间的交互方式）
• 数据库设计（设计数据存储结构）
  • 表结构（定义数据表和字段）
  • 索引设计（加速数据查询）
  • 关系模型（确定表与表之间的关系）
• UI设计（设计用户界面和交互体验）
  • 交互设计（规划用户操作流程）
  • 视觉设计（界面美观和风格统一）
  • 响应式设计（适配不同设备和屏幕）

16.3 开发阶段

• 编码规范（统一代码风格和格式）
  • 命名规范（统一变量、函数、类名的命名方式）
  • 注释规范（为关键代码添加说明）
  • 格式规范（统一缩进、空格、换行等）
• 代码审查（团队成员互查代码，提升质量）
  • 代码质量（用工具和人工检查代码）
  • 性能优化（发现和优化性能瓶颈）
  • 安全审查（检查安全隐患）
• 版本控制（用Git等工具管理代码历史）
  • 分支管理（合理划分和合并分支）
  • 代码合并（合并不同开发线索的代码）
  • 版本发布（打标签、发布新版本）

16.4 测试阶段

• 测试计划（制定测试目标和范围）
  • 测试范围（明确要测试的内容）
  • 测试策略（选择合适的测试方法）
  • 资源分配（安排测试人员和环境）
• 测试执行（实际运行测试用例）
  • 单元测试（测试最小功能单元）
  • 集成测试（测试模块间协作）
  • 系统测试（测试整个系统的功能）
• 测试报告（记录和分析测试结果）
  • 缺陷统计（统计发现的问题和缺陷）
  • 性能指标（记录系统性能数据）
  • 改进建议（提出优化和改进措施）

17. 开发环境配置

17.1 本地环境

• 开发工具（如IDE、编辑器、终端，辅助开发的工具）
  • IDE配置（根据项目需求调整IDE设置）
  • 编辑器配置（自定义快捷键、主题等）
  • 终端配置（配置命令行环境）
• 运行环境（本地安装的语言、数据库、缓存等）
  • 语言环境（如Python、Java、Node.js等的安装和配置）
  • 数据库环境（如MySQL、PostgreSQL等的本地部署）
  • 缓存环境（如Redis、Memcached等的本地部署）
• 调试环境（本地调试和分析程序的环境）
  • 调试工具（如gdb、pdb等）
  • 日志配置（设置日志输出格式和级别）
  • 性能分析（用工具分析程序性能）

17.2 测试环境

• 环境搭建（为测试准备的专用环境）
  • 服务器配置（配置测试服务器的硬件和软件）
  • 网络配置（设置测试网络环境）
  • 存储配置（分配测试用的存储空间）
• 环境管理（维护和同步测试环境）
  • 环境隔离（保证测试环境与生产环境互不影响）
  • 环境同步（保持测试环境与生产环境一致）
  • 环境备份（定期备份测试环境数据）
• 环境监控（实时监控测试环境状态）
  • 资源监控（监控CPU、内存、磁盘等资源）
  • 性能监控（监控系统性能指标）
  • 告警配置（设置异常自动报警）

17.3 生产环境

• 环境规划（提前设计生产环境的架构和资源分配）
  • 服务器规划（确定服务器数量和配置）
  • 网络规划（设计网络结构和安全策略）
  • 存储规划（分配存储资源和备份方案）
• 环境部署（上线和维护生产环境）
  • 部署方案（选择合适的部署方式）
  • 回滚方案（部署失败时快速恢复）
  • 应急预案（应对突发故障的措施）
• 环境运维（日常维护和优化生产环境）
  • 监控告警（实时监控和报警）
  • 日志管理（收集和分析运行日志）
  • 性能优化（持续提升系统性能）

17.4 环境迁移

• 迁移计划（制定详细的迁移步骤和时间表）
  • 风险评估（分析迁移可能带来的风险）
  • 时间规划（合理安排迁移时间）
  • 资源准备（提前准备好所需资源）
• 迁移执行（实际操作迁移过程）
  • 数据迁移（安全高效地转移数据）
  • 配置迁移（迁移系统和应用配置）
  • 应用迁移（迁移和部署应用程序）
• 迁移验证（确保迁移后系统正常运行）
  • 功能验证（检查所有功能是否正常）
  • 性能验证（测试系统性能是否达标）
  • 安全验证（检查安全设置是否正确）

图表说明

1. 模块化设计：每个核心知识领域（如Git、CMake，分别是主流的版本控制工具和构建系统）拆解为可快速定位的子问题。
2. 重点突出：
   • 红色节点（如B2a，表示高频使用场景，比如CMake单文件模板，CMake是跨平台构建工具）
   • 绿色节点（如E2a，表示易错点，比如Git回滚操作，Git是分布式版本控制系统）
3. 实用导向：直接关联具体工具（如vcpkg是C/C++包管理器，Wireshark是网络抓包工具）和示例（如OpenCV是计算机视觉库，Eigen是线性代数库）。

如何使用？

1. 作为学习地图：按箭头顺序逐步掌握（如先环境→依赖→Git，依赖是项目所需的外部库，Git是代码管理工具）。
2. 作为检查清单：开发时对照节点确认是否遗漏（如SDK初始化是否完成日志配置，SDK是软件开发工具包，日志用于记录程序运行信息）。
3. 扩展维护：后续新增知识模块时，直接添加节点并链接关联区域（节点是图表中的知识点，关联区域是相关内容的集合）。