diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index e349624..b1f3b14 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -2,7 +2,7 @@ Please include a summary of the change and which issue is fixed. ## Checklist -- [ ] Content changes have been applied to all three languages (English, Russian, Chinese) OR a follow-up issue has been opened to track missing translations. +- [ ] Content changes have been applied to all four languages (English, Russian, Chinese, Spanish) OR a follow-up issue has been opened to track missing translations. - [ ] Any new external links have been verified. (If a link is bot-blocked and fails CI, it has been added to `.lycheeignore` with a comment). - [ ] I have run `lychee --offline --no-progress "**/*.md"` locally (see `CONTRIBUTING.md`); if I added external links, I checked those too. - [ ] **If I changed the map**: I edited `tools/mapgen/roadmap/` (not the `.drawio.svg`), rebuilt with `python tools/mapgen/build.py --dir tools/mapgen/roadmap --deploy --check`, and committed the regenerated maps — or I said in the description that a maintainer needs to regenerate them. diff --git a/AGENTS.md b/AGENTS.md index ae1883d..d63d96f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -3,8 +3,7 @@ This file helps an AI agent (or a human) get up to speed on the repository quickly: how the map is produced, how to change it safely, and the conventions to keep. -This is **not a changelog** — for what changed and when, see the git history; the owner's -current tasks live in [TODO.md](TODO.md). +This is **not a changelog** — for what changed and when, see the git history. > **IMPORTANT: the maps are GENERATED, not hand-edited.** > Each `/Graph/roadmap.drawio.svg` is **build output** of the mapgen pipeline. @@ -19,8 +18,7 @@ current tasks live in [TODO.md](TODO.md). - `main` is the primary branch; work through separate branches and pull requests. - Article file names and URLs must not change — they are linked from outside. - **Articles** (the per-language `.md` content) are still maintained by hand, one copy per - language; any content change must be mirrored across `English/` `Russian/` `Chinese/` - (there is no `Spanish/` yet). **The map is different** — it has a single source (below), + language; any content change must be mirrored across `English/` `Russian/` `Chinese/` `Spanish/`. **The map is different** — it has a single source (below), so a structural change is made once and regenerated into every language. ## How the map is produced @@ -48,10 +46,10 @@ tools/mapgen/roadmap/structure.dsl + .tsv ──► build.py ── 1. Edit the source in `tools/mapgen/roadmap/`: - **structure / grade / stage / hint placement** → `structure.dsl` - **text** (a label, a hint's wording, the date, a legend caption) → the relevant - `.tsv` row(s). A structural add needs a new row in **all three** tsvs. + `.tsv` row(s). A structural add needs a new row in **all four** tsvs. 2. First time on a machine: `python tools/mapgen/setup.py --venv` (creates a virtualenv, installs Pillow, and reports how to install the draw.io desktop app if it is missing). -3. Rebuild, update all three live maps, and validate — one command from the repo root: +3. Rebuild, update all four live maps, and validate — one command from the repo root: ```bash python tools/mapgen/build.py --dir tools/mapgen/roadmap --deploy --check ``` @@ -79,7 +77,7 @@ normal edit loop. - **Stage frames** grow to fit their `(section, stage)` group automatically; the "N step" titles come from the `stage1`..`stage5` tsv keys. Just annotate a subtree root with `stage=N`. - **Hints** are placed by explicit polar `angle`/`dist` from their target and a required - `arrow=` side; one value serves all three languages, so re-check `mapcheck` after moving one. + `arrow=` side; one value serves all four languages, so re-check `mapcheck` after moving one. - Rows share `y` across languages (`PITCH=60`, box `H=30`); only x/width differ per language. The generator handles this — you don't port vertical positions by hand any more. @@ -97,4 +95,3 @@ cross-language drift and a stale date. See [`tools/mapcheck/README.md`](tools/ma behind; they are marked obsolete in every language's README. Optional plan: check GoatCounter traffic for `/goto/miro-*` vs `/goto/svg-*`; if low, put a "the map has moved" banner on the boards and redirect `goto/miro` to the SVG viewer (without breaking links). -- **The owner's current tasks are in [TODO.md](TODO.md)**; check it directly. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 785514d..a6bb4e9 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -4,11 +4,11 @@ Thank you for your interest in contributing! To maintain consistency and quality ## Language Sync Rule -This project maintains parity across three languages: English (`English/`), Russian (`Russian/`), and Chinese (`Chinese/`). -**Any content change (e.g., adding a book, updating a tool, fixing a description) MUST be mirrored across all three languages.** -If you are unable to translate the content into all languages, please create an issue or note it in your Pull Request so someone can help translate it. +This project maintains parity across four languages: English (`English/`), Russian (`Russian/`), Chinese (`Chinese/`), and Spanish (`Spanish/`). +**Any content change (e.g., adding a book, updating a tool, fixing a description) MUST be mirrored across all four languages.** +You do not need to be fluent in all four to contribute — use a translation tool (like Google Translate or DeepL) for the languages you don't speak, and reviewers will polish it. The important part is that the files stay structurally identical (same headings, same order). -This rule is about the **articles** (the `.md` files). **The map is different** — it has one shared source, so a structural change is made once and regenerated into all three languages; only its *text* is per-language. See below. +This rule is about the **articles** (the `.md` files). **The map is different** — it has one shared source, so a structural change is made once and regenerated into all four languages; only its *text* is per-language. See below. ## Editing the Roadmap @@ -18,13 +18,13 @@ The roadmap is **generated** from a single language-neutral source in [`tools/ma 1. Edit `structure.dsl` (to add/move/re-grade a node or a hint) and/or the `.tsv` files (to change text — one row per language). 2. Set your machine up once — `python tools/mapgen/setup.py --venv` creates a virtualenv, installs Pillow, and tells you how to install the draw.io desktop app if you don't have it. -3. Rebuild and update all three maps with one command from the repo root, then open a pull request: +3. Rebuild and update all four maps with one command from the repo root, then open a pull request: ```bash python tools/mapgen/build.py --dir tools/mapgen/roadmap --deploy --check ``` See [`tools/mapgen/README.md`](tools/mapgen/README.md) for the DSL grammar and all flags. -Because there is one structural source, a structural change lands in all three languages at once — you only supply the per-language **text** in each `.tsv`. If you can't run the build locally (`setup.py` will tell you what's missing — the draw.io desktop app is the usual blocker), edit the source anyway and say so in your PR; a maintainer will regenerate the maps. To just *view* the map, see the per-language [`Graph/README.md`](English/Graph/README.md). +Because there is one structural source, a structural change lands in all four languages at once — you only supply the per-language **text** in each `.tsv`. If you can't run the build locally (`setup.py` will tell you what's missing — the draw.io desktop app is the usual blocker), edit the source anyway and say so in your PR; a maintainer will regenerate the maps. To just *view* the map, see the per-language [`Graph/README.md`](English/Graph/README.md). ## Local Jekyll Preview diff --git a/Chinese/Graph/README.md b/Chinese/Graph/README.md index 7ed5dc0..f86961a 100644 --- a/Chinese/Graph/README.md +++ b/Chinese/Graph/README.md @@ -19,14 +19,14 @@ 1. Fork 本仓库并编辑源文件： - 节点、其等级/阶段或提示 → `tools/mapgen/roadmap/structure.dsl` - - 文字（标签、提示、日期）→ `en.tsv` / `ru.tsv` / `zh.tsv` 中对应的行（新节点需要在**三个文件中都**加一行）。 + - 文字（标签、提示、日期）→ `en.tsv` / `ru.tsv` / `zh.tsv` / `es.tsv` 中对应的行（新节点需要在**四个文件中都**加一行）。 2. **仅首次需要** — 准备好你的环境： ```bash python tools/mapgen/setup.py --venv ``` 它会创建虚拟环境、安装 Pillow，并检查两个它无法替你安装的东西（CJK 字体和 draw.io 桌面应用），如果缺少就打印适用于你操作系统的确切命令。 -3. 在仓库根目录用一条命令重新构建、更新全部三张地图并进行校验： +3. 在仓库根目录用一条命令重新构建、更新全部四张地图并进行校验： ```bash python tools/mapgen/build.py --dir tools/mapgen/roadmap --deploy --check ``` diff --git a/Chinese/Graph/roadmap.drawio.svg b/Chinese/Graph/roadmap.drawio.svg index 99b4132..6f81238 100644 --- a/Chinese/Graph/roadmap.drawio.svg +++ b/Chinese/Graph/roadmap.drawio.svg @@ -1,4 +1,4 @@ -步骤 1步骤 2步骤 3步骤 4步骤 1步骤 3步骤 5步骤 1步骤 4步骤 2C++ 开发者软性技能学习能力提出正确的问题信息处理实验实操知识管理管理错误分析错误承认您的错误出现错误及时通知接受批评思考逻辑性系统性批判性创意性策略责任纪律坚持主动性独立解决问题资源管理时间管理管理优先级作决定盲打多重任务同时进行交流沟通协商倾听说服团队内部交流创意和想法的能力向团队以外的人员提供信息的能力寻求妥协解决争议英文能力演讲演示书面沟通技巧社交团队协作理解团队内的角色分工支持帮助团队成员在分布式团队中工作提供意见反馈领导力向员工分配和明确任务计划并制订目标启导、指导他人委派工作情绪智力（情商）抗压能力在不确定性中工作适应性思想开明专注共情理解开发背景以客户为中心技术发展趋势硬性技能C++语法基本运算算术运算逻辑运算循环: for/while位运算函数运算符Lambda表达式数据类型静态类型动态类型RTTI（运行时类型识别）指针&引用引用智能指针（smart pointer）unique_ptrshared_ptrweak_ptr内存模型对象生命周期原始指针new/delete 运算符内存泄漏代码库结构化代码拆分为 headers/cpp 文件前向声明作用域（Scope）命名空间（Namespace）结构体（Struct）和类（class）面向对象编程 (OOP)静态多态（Static polymorphism）函数重载动态多态（Dynamic polymorphism）虚函数（Virtual methods）虚函数表（Virtual table, vtbl)三/五/零法则多重继承（Multiple inheritance）钻石继承（Diamond inheritance）异常处理std::optional / std::expected异常（Exceptions）非法访问（Access violation）noexcept错误码（Error codes）std::error_code语言概念（Language concepts）自动类型推导 auto (automatic type deduction)类型转换（type casting）静态类型转换（static_cast）const_cast动态类型转换（dynamic_cast）reinterpret_cast未定义行为 （Undefined Behavior，UB)参数依赖查找（Argument-dependent lookup，ADL)constexpr / consteval宏（Macros）名字改写（Name mangling）移动语义值类别（lvalue/rvalue）std::move / std::forward完美转发（Perfect forwarding）Coroutines (C++20)Modules (C++20)标准程序库+标准模板库（Standard library + STL）输入输出流（iostream）std::format / std::printDate/time容器（Containers）std::span / std::string_view迭代器（Iterators）算法（Algorithms）std::ranges多线程（Multithreading）模板（Template）可变参数模板 (Variadic templates)模板特化（Template specialization）模板全特化（Full template specialization）模板偏特化（Partial template specialization）类型特征（type traits）SFINAEConcepts (C++20)惯常用法/设计习语（Idioms）RAII（资源获取即初始化）pimpl（指向实现的指针）Non-Copyable （不可复制）/Non-Moveable（不可移动）Erase-Remove（删除）Copy and swap（复制并交换）Copy on write（写时复制）CRTP（奇异递归模板）标准（Standards）C++11/14C++17C++20C++23C++26 (newest)C++语言工具使用源代码文本编辑器集成开发环境（IDE）代码编辑器熟悉编辑器的特性和功能范畴（快捷键、工具、插件）调试器（Debugger）理解调试器所反馈出的信息调试符号（Debugging symbols）WinDbgGDBLLDBLintersCompiler Explorer (godbolt.org)编译器（Compilers）对编译过程的基本了解将源代码编译为目标文件（compilation）目标文件链接过程 (linking)编译器的编译过程特定编译器的特性构建系统（Build systems）CMakeMakefileninja包管理器（Package managers）Conannugetvcpkgspack使用程序库引用库（Libraries inclusion）软件授权许可（Licensing）库（Library)boostopencvpocoprotobufAsiogRPCfmtnlohmann/jsonpybind11spdlogrange-v3tensorflowopencl框架（Frameworks）gtest/gmockQtcatch2google benchmarkgoogle profilerpytorch c++通用技能计算机科学数据结构布尔代数（Boolean algebra）算法有限状态机（Finite-state machines）版本控制软件（Version Control）分布式gitMercurial集中式SVN最佳实践代码质量代码指南开发原则KISS (Keep It Simple, Stupid) 保持简约、简单DRY (Don't Repeat Yourself) 不要重复你自己（不写重复代码）YAGNI (You Aren't Gonna Need It) 你不需要它APO (Avoid Premature Optimization) 避免过早优化BDUF (Big Design Up Front) 前期大型设计Composition is preferably than the inheritance 组合优于继承Occam's razor 奥卡姆剃刀原理（简约法则）Divide and Conquer 分治法记录和遥测（Logging and telemetry）代码评审（Code review）阅读理解现有代码的能力评审代码的能力软件生命周期实现（Implementation）测试单元测试（Unit tests）集成测试（Integration tests）功能测试（Functional tests）性能测试（Performance tests）维护版本管理（Versioning）向后兼容（Backward compatibility）软件架构和组件设计组件集成软件部署（Deployment）征集要求软件生命周期结束代码分析器（Code analyzers）静态分析器（Static analyzers）动态分析器（Dynamic analyzers）ProfilersValgrindperf / VTuneC++ 核心指南Microsoft GSL行业标准MISRA C++:2023AutosarEU Cyber Resilience Act (CRA)SBOMIEC 62304（医疗）ISO 26262（汽车）DO-178C（航空）命令行PowershellbatchbashCI/CD（持续集成、持续部署）创建软件部署包文档安装包主干开发（Trunk Based Development）零停机时间部署（Zero downtime deployment）AI 工具AI 助手（Copilot, Claude Code, Cursor）验证生成的代码公司政策与保密生成代码的许可风险本地模型其他编程语言的使用语言互操作性（Language interoperability）软件设计设计模式 Design Patters (GoF)结构模式（Structural）行为模式（Behavioral）创建模式（Creational）面向对象编程 (OOP)SOLIDUML软件架构风格基于组件 Component-based单体式应用程序 Monolithic application分层模式 Layered客户/服务器模式 Client-server微服务架构 Microservices architecture事件驱动架构 Event-driven插件Plug-insREST面向服务的架构 Service-oriented architecture架构模式MVC 模型-视图-控制器模式MVVMThree-tier 三层架构OnionHexagon开发方法论测试驱动开发（Test Driven Development）行为驱动开发（Behavior Driven Development）领域驱动设计（Domain Driven Design）操作系统二进制单位可执行文件（Executable file）静态库（Static library)动态库（Dynamic library）内存内存抽象（Memory abstractions）栈（Stack）堆（Heap）全局内存（Global memory）应用内存（Application memory）内存对齐（Memory alignment）内存管理（Memory management）虚拟内存（Virtual memory）线程（Threads）多线程错误死锁（Dead lock）竞态条件（Race condition）活锁（Live lock）饥饿（Starvation）std::atomic，C++ 内存模型并发（Concurrency）互斥锁 （Mutexes）信号量（Semaphores）无锁（lock-free）condition_variablefuture / promise / asyncjthread (C++20)事件处理（Event handling）同步（Sync）异步（Async）OpenMP / TBB过程（Process）进程间通信（Interprocess communication）共享内存（Shared memory）管道（Pipes）序列化（Serialization）jsonXML网络（Network）TCP/IPSocketsTCPUDPHTTPOSI文件系统（File system）任务调度（Task scheduler）虚拟化（Virtualization）VirtualBoxVMware WorkstationHyper-V容器（Containers）DockerKubernetes云服务（Cloud Services）程序安全漏洞：buffer overflow、use-after-freeSanitizers (ASan / TSan / UBSan)加密FuzzingCERT C++ / CWEMultiCPU systemsMulticore CPUNUMA输入/输出（Input/output）驱动程序（Drivers）音频（Audio）DirectSoundOpenAL显卡（Graphics）DirectXOpenGLVulkanCUDA打印机/打印 Printers (printing)常规或自定义类型 (结构/类)的常规运 算符的重载。为防止内存泄漏 问题，最好使用智能指针而不是 原始指针。代码中最好避免 出现多重继承 (抽象类除外)， 以防止运行时出现问题根据 ISO 标准，某些语言结构具有未定义行为。 如果出现任何错误，则无法预测程序进 一步的行为，因为程序此后的行为取决 于平台环境、运行时的上下文具体内容等。收集、分析、评估信息，并据此做出决 策的能力。选择一款你喜欢的流行 IDE 并好好掌握它： MS Visual Studio、VS Code、Qt Creator JetBrainsCLion、Xcode 等。选择一款流行的编辑器并好好掌握它。 例如：Notepad++、Sublime Text 等。选择一款流行的编辑器并好好掌握它。 例如：VS Code、Sublime Text、Zed 等。了解常见错误（段错误 segfault,内存溢出 out of memory, 非法访问 access violation) 以及未定义行为（undefined behavior）的概念。反思学习如何使用调试器，并深入了解 调试器所具有的所有功能。通过命令行来使用调试器并非 一项常规技能。掌握通过IDE来 使用调试器的能力就足够了， 例如通过IDE设置断点，等等。冷静地回应他人的评论。很有 可能他人所说的话、试图证明 的事情，仅仅基于他们自己的 角度，这是可以理解的。请客 观地评估他人观点的有用性。编译器执行代码编译过程的数个阶段。 对所有这些阶段进行基本的了解将有助 于更好地理解编译中可能出现的问题。 不过，只有编译器创建者才需要深入了 解编译器知识。主动承担具有挑战性的任务，以发展您的技 能和能力，即便此刻您还不具备完全足够的 知识或经验（您的技能将会通过此类任务得 到快速发展）。关键是要能够区分出：哪些 是真正有助于您提升技能的复杂任务，而哪 些又是仅仅需要替罪羊的愚蠢的任务。每个编译器之间有细微的差别。最好对这些差别有所了解，以避免 陷入一些陷阱：Clang++/LLVM，Intel C++，MSVS C++，GCC，MinGW您应该对自己的职业发展负责。不要等待团队领导来决定您要学习什么。请不要忘记，盲 目遵循他人安排的计划，只会让您提高某些适用于某特定 公司的技能。最好商讨如何将您的个人利益和兴趣也纳入计划之中， 否则的话，就很有可能将时间花在不相关的技能上，从而 影响职业机会。不过切记不要太极端：别不加选择地什么 都学，也不要什么都拒绝直到有一个完美的量身定制的学 习计划出现。仔细阅读许可协议的条款。 您的项目必须遵守这些条款， 才能使用这些库。自组织（Self- organization）有能力根据各方人员不 同的背景，而提供适量 、适当的信息，以促进 有效的沟通交流。一开始，有些技能看似没有 办法习得或提升。然而，在 我们看来，这里所列的每一 项技能，都是可以通过练习 得以提升的。每个人的学习 目的不同，最终成效取决于 您个人的愿望和努力 :)解决冲突如果您阅读本路线图，您大概率已经注 意到英文能力有多重要:)通常，您至少需要具备英文阅读能力， 因为您要能够读懂技术文档。不过，随 着您在职业阶梯上的步步晋升，您将同 时需要更加自信地用英文说和写。寻找志同道合的人，并 加入或创建相关社区， 以进行经验交流。了解如何计算算法复 杂度，和如何计算内 存消耗也很有好处。您应当研究和观察当代发展趋势，以保 持自己的竞争力， 并适应变化。经验丰富的开发人员应该培养管理技能 和业务沟通技能，以高效地完成任务。 如果您有较好的情商，那这就相对更容 易做到。 对于初级开发人员来说，共情能力在与 同事互动中也是非常有用的。用于结合以下任意一种工具来配置自动代码格式验证：clang-format 代码格式,Resharper - 代码风格，MSVS - 代码风格。命名规则（naming conventin）， tab键 vs 空格键 space，等等。不要忽略来自编译器或任何代码分析器的警告。 他们是你的朋友，而不是敌人。AI 可能生成看似合理但错误的代码—— 请验证并测试一切。 必须掌握 C++。- Scripting - Functional - SQLlike - NoSQL有时需要具备能够重用由另 一种语言编写成的库的能力 。 例如：在C#中调用C++库。memory safety 要求日益提高（美国和 欧盟监管机构）。请学习安全实践 与分析工具。
С++ 开发者路线图
最后更新：2026-07-25
简介
C++至今仍旧是最受欢迎的开发语言之一，有很多人想要开始学习C++并成为开发者。初学者通常会面临这样 的问题：“我应当从何开始？我需要学些什么？应当以什么样的顺序去学？我需要参考哪些书籍？ 我们希望通过这份路线图来回答这些问题。本图旨在帮助初学者或经验有限的人士，所涵盖的内容侧重于可 用在大多数开发项目中的通用能力和技能。如果您参考本路线图所罗列的相关材料，您将可以为自己创建一 个高效的学习计划，而不被次要信息分心。本路线图将帮助您达到一个许多商业项目普遍要求的C++水平。 详细信息: https://github.com/salmer/CppDeveloperRoadmap
创作者
https://github.com/salmer/CppDeveloperRoadmap
如何使用
反馈与沟通
初学者需注意，对于中级和高 级的技能，只需掌握基本概念 即可。
中级开发者具备以下能力： 可以为一款应用程序设计出 新的功能，即便是缺乏对于 该项新功能的完善的具体要 求或相关信息。
选修
如您有任何意见或建议，请随时与我们联系。我们将感激不尽 :) 您可通过以下任一Github链接联系我们
高级
中级
初级
初学者必须尽快掌握以下技能 : 编写易读且结构良好的代码。
本路线图标示出了学习“步骤”。 这些“步骤”旨在规划出一套 易于操作的学习计划，以帮助 初学者在获取足够的C++基础 知识的同时，逐步提升深入学 习的信心。
高级开发者具备以下能力： 结合业务领域的相关背景， 设计出解决方案/组件，并作 出相关决策。
Text is not SVG - cannot display \ No newline at end of file +步骤 1步骤 2步骤 3步骤 4步骤 1步骤 3步骤 5步骤 1步骤 4步骤 2C++ 开发者软性技能学习能力提出正确的问题信息处理实验实操知识管理管理错误分析错误承认您的错误出现错误及时通知接受批评思考逻辑性系统性批判性创意性策略责任纪律坚持主动性独立解决问题资源管理时间管理管理优先级作决定盲打多重任务同时进行交流沟通协商倾听说服团队内部交流创意和想法的能力向团队以外的人员提供信息的能力寻求妥协解决争议英文能力演讲演示书面沟通技巧社交团队协作理解团队内的角色分工支持帮助团队成员在分布式团队中工作提供意见反馈领导力向员工分配和明确任务计划并制订目标启导、指导他人委派工作情绪智力（情商）抗压能力在不确定性中工作适应性思想开明专注共情理解开发背景以客户为中心技术发展趋势硬性技能C++语法基本运算算术运算逻辑运算循环: for/while位运算函数运算符Lambda表达式数据类型静态类型动态类型RTTI（运行时类型识别）指针&引用引用智能指针（smart pointer）unique_ptrshared_ptrweak_ptr内存模型对象生命周期原始指针new/delete 运算符内存泄漏代码库结构化代码拆分为 headers/cpp 文件前向声明作用域（Scope）命名空间（Namespace）结构体（Struct）和类（class）面向对象编程 (OOP)静态多态（Static polymorphism）函数重载动态多态（Dynamic polymorphism）虚函数（Virtual methods）虚函数表（Virtual table, vtbl)三/五/零法则多重继承（Multiple inheritance）钻石继承（Diamond inheritance）异常处理std::optional / std::expected异常（Exceptions）非法访问（Access violation）noexcept错误码（Error codes）std::error_code语言概念（Language concepts）自动类型推导 auto (automatic type deduction)类型转换（type casting）静态类型转换（static_cast）const_cast动态类型转换（dynamic_cast）reinterpret_cast未定义行为 （Undefined Behavior，UB)参数依赖查找（Argument-dependent lookup，ADL)constexpr / consteval宏（Macros）名字改写（Name mangling）移动语义值类别（lvalue/rvalue）std::move / std::forward完美转发（Perfect forwarding）Coroutines (C++20)Modules (C++20)标准程序库+标准模板库（Standard library + STL）输入输出流（iostream）std::format / std::printDate/time容器（Containers）std::span / std::string_view迭代器（Iterators）算法（Algorithms）std::ranges多线程（Multithreading）模板（Template）可变参数模板 (Variadic templates)模板特化（Template specialization）模板全特化（Full template specialization）模板偏特化（Partial template specialization）类型特征（type traits）SFINAEConcepts (C++20)惯常用法/设计习语（Idioms）RAII（资源获取即初始化）pimpl（指向实现的指针）Non-Copyable （不可复制）/Non-Moveable（不可移动）Erase-Remove（删除）Copy and swap（复制并交换）Copy on write（写时复制）CRTP（奇异递归模板）标准（Standards）C++11/14C++17C++20C++23C++26 (newest)C++语言工具使用源代码文本编辑器集成开发环境（IDE）代码编辑器熟悉编辑器的特性和功能范畴（快捷键、工具、插件）调试器（Debugger）理解调试器所反馈出的信息调试符号（Debugging symbols）WinDbgGDBLLDBLintersCompiler Explorer (godbolt.org)编译器（Compilers）对编译过程的基本了解将源代码编译为目标文件（compilation）目标文件链接过程 (linking)编译器的编译过程特定编译器的特性构建系统（Build systems）CMakeMakefileninja包管理器（Package managers）Conannugetvcpkgspack使用程序库引用库（Libraries inclusion）软件授权许可（Licensing）库（Library)boostopencvpocoprotobufAsiogRPCfmtnlohmann/jsonpybind11spdlogrange-v3tensorflowopencl框架（Frameworks）gtest/gmockQtcatch2google benchmarkgoogle profilerpytorch c++通用技能计算机科学数据结构布尔代数（Boolean algebra）算法有限状态机（Finite-state machines）版本控制软件（Version Control）分布式gitMercurial集中式SVN最佳实践代码质量代码指南开发原则KISS (Keep It Simple, Stupid) 保持简约、简单DRY (Don't Repeat Yourself) 不要重复你自己（不写重复代码）YAGNI (You Aren't Gonna Need It) 你不需要它APO (Avoid Premature Optimization) 避免过早优化BDUF (Big Design Up Front) 前期大型设计Composition is preferably than the inheritance 组合优于继承Occam's razor 奥卡姆剃刀原理（简约法则）Divide and Conquer 分治法记录和遥测（Logging and telemetry）代码评审（Code review）阅读理解现有代码的能力评审代码的能力软件生命周期实现（Implementation）测试单元测试（Unit tests）集成测试（Integration tests）功能测试（Functional tests）性能测试（Performance tests）维护版本管理（Versioning）向后兼容（Backward compatibility）软件架构和组件设计组件集成软件部署（Deployment）征集要求软件生命周期结束代码分析器（Code analyzers）静态分析器（Static analyzers）动态分析器（Dynamic analyzers）ProfilersValgrindperf / VTuneC++ 核心指南Microsoft GSL行业标准MISRA C++:2023AutosarEU Cyber Resilience Act (CRA)SBOMIEC 62304（医疗）ISO 26262（汽车）DO-178C（航空）命令行PowershellbatchbashCI/CD（持续集成、持续部署）创建软件部署包文档安装包主干开发（Trunk Based Development）零停机时间部署（Zero downtime deployment）AI 工具AI 助手（Copilot, Claude Code, Cursor）验证生成的代码公司政策与保密生成代码的许可风险本地模型其他编程语言的使用语言互操作性（Language interoperability）软件设计设计模式 Design Patters (GoF)结构模式（Structural）行为模式（Behavioral）创建模式（Creational）面向对象编程 (OOP)SOLIDUML软件架构风格基于组件 Component-based单体式应用程序 Monolithic application分层模式 Layered客户/服务器模式 Client-server微服务架构 Microservices architecture事件驱动架构 Event-driven插件Plug-insREST面向服务的架构 Service-oriented architecture架构模式MVC 模型-视图-控制器模式MVVMThree-tier 三层架构OnionHexagon开发方法论测试驱动开发（Test Driven Development）行为驱动开发（Behavior Driven Development）领域驱动设计（Domain Driven Design）操作系统二进制单位可执行文件（Executable file）静态库（Static library)动态库（Dynamic library）内存内存抽象（Memory abstractions）栈（Stack）堆（Heap）全局内存（Global memory）应用内存（Application memory）内存对齐（Memory alignment）内存管理（Memory management）虚拟内存（Virtual memory）线程（Threads）多线程错误死锁（Dead lock）竞态条件（Race condition）活锁（Live lock）饥饿（Starvation）std::atomic，C++ 内存模型并发（Concurrency）互斥锁 （Mutexes）信号量（Semaphores）无锁（lock-free）condition_variablefuture / promise / asyncjthread (C++20)事件处理（Event handling）同步（Sync）异步（Async）OpenMP / TBB过程（Process）进程间通信（Interprocess communication）共享内存（Shared memory）管道（Pipes）序列化（Serialization）jsonXML网络（Network）TCP/IPSocketsTCPUDPHTTPOSI文件系统（File system）任务调度（Task scheduler）虚拟化（Virtualization）VirtualBoxVMware WorkstationHyper-V容器（Containers）DockerKubernetes云服务（Cloud Services）程序安全漏洞：buffer overflow、use-after-freeSanitizers (ASan / TSan / UBSan)加密FuzzingCERT C++ / CWEMultiCPU systemsMulticore CPUNUMA输入/输出（Input/output）驱动程序（Drivers）音频（Audio）DirectSoundOpenAL显卡（Graphics）DirectXOpenGLVulkanCUDA打印机/打印 Printers (printing)常规或自定义类型 (结构/类)的常规运 算符的重载。为防止内存泄漏 问题，最好使用智能指针而不是 原始指针。代码中最好避免 出现多重继承 (抽象类除外)， 以防止运行时出现问题根据 ISO 标准，某些语言结构具有未定义行为。 如果出现任何错误，则无法预测程序进 一步的行为，因为程序此后的行为取决 于平台环境、运行时的上下文具体内容等。收集、分析、评估信息，并据此做出决 策的能力。选择一款你喜欢的流行 IDE 并好好掌握它： MS Visual Studio、VS Code、Qt Creator JetBrainsCLion、Xcode 等。选择一款流行的编辑器并好好掌握它。 例如：Notepad++、Sublime Text 等。选择一款流行的编辑器并好好掌握它。 例如：VS Code、Sublime Text、Zed 等。了解常见错误（段错误 segfault,内存溢出 out of memory, 非法访问 access violation) 以及未定义行为（undefined behavior）的概念。反思学习如何使用调试器，并深入了解 调试器所具有的所有功能。通过命令行来使用调试器并非 一项常规技能。掌握通过IDE来 使用调试器的能力就足够了， 例如通过IDE设置断点，等等。冷静地回应他人的评论。很有 可能他人所说的话、试图证明 的事情，仅仅基于他们自己的 角度，这是可以理解的。请客 观地评估他人观点的有用性。编译器执行代码编译过程的数个阶段。 对所有这些阶段进行基本的了解将有助 于更好地理解编译中可能出现的问题。 不过，只有编译器创建者才需要深入了 解编译器知识。主动承担具有挑战性的任务，以发展您的技 能和能力，即便此刻您还不具备完全足够的 知识或经验（您的技能将会通过此类任务得 到快速发展）。关键是要能够区分出：哪些 是真正有助于您提升技能的复杂任务，而哪 些又是仅仅需要替罪羊的愚蠢的任务。每个编译器之间有细微的差别。最好对这些差别有所了解，以避免 陷入一些陷阱：Clang++/LLVM，Intel C++，MSVS C++，GCC，MinGW您应该对自己的职业发展负责。不要等待团队领导来决定您要学习什么。请不要忘记，盲 目遵循他人安排的计划，只会让您提高某些适用于某特定 公司的技能。最好商讨如何将您的个人利益和兴趣也纳入计划之中， 否则的话，就很有可能将时间花在不相关的技能上，从而 影响职业机会。不过切记不要太极端：别不加选择地什么 都学，也不要什么都拒绝直到有一个完美的量身定制的学 习计划出现。仔细阅读许可协议的条款。 您的项目必须遵守这些条款， 才能使用这些库。自组织（Self- organization）有能力根据各方人员不 同的背景，而提供适量 、适当的信息，以促进 有效的沟通交流。一开始，有些技能看似没有 办法习得或提升。然而，在 我们看来，这里所列的每一 项技能，都是可以通过练习 得以提升的。每个人的学习 目的不同，最终成效取决于 您个人的愿望和努力 :)解决冲突如果您阅读本路线图，您大概率已经注 意到英文能力有多重要:)通常，您至少需要具备英文阅读能力， 因为您要能够读懂技术文档。不过，随 着您在职业阶梯上的步步晋升，您将同 时需要更加自信地用英文说和写。寻找志同道合的人，并 加入或创建相关社区， 以进行经验交流。了解如何计算算法复 杂度，和如何计算内 存消耗也很有好处。您应当研究和观察当代发展趋势，以保 持自己的竞争力， 并适应变化。经验丰富的开发人员应该培养管理技能 和业务沟通技能，以高效地完成任务。 如果您有较好的情商，那这就相对更容 易做到。 对于初级开发人员来说，共情能力在与 同事互动中也是非常有用的。用于结合以下任意一种工具来配置自动代码格式验证：clang-format 代码格式,Resharper - 代码风格，MSVS - 代码风格。命名规则（naming conventin）， tab键 vs 空格键 space，等等。不要忽略来自编译器或任何代码分析器的警告。 他们是你的朋友，而不是敌人。AI 可能生成看似合理但错误的代码—— 请验证并测试一切。 必须掌握 C++。- Scripting - Functional - SQLlike - NoSQL有时需要具备能够重用由另 一种语言编写成的库的能力 。 例如：在C#中调用C++库。memory safety 要求日益提高（美国和 欧盟监管机构）。请学习安全实践 与分析工具。
С++ 开发者路线图
最后更新：2026-09-02
简介
C++至今仍旧是最受欢迎的开发语言之一，有很多人想要开始学习C++并成为开发者。初学者通常会面临这样 的问题：“我应当从何开始？我需要学些什么？应当以什么样的顺序去学？我需要参考哪些书籍？ 我们希望通过这份路线图来回答这些问题。本图旨在帮助初学者或经验有限的人士，所涵盖的内容侧重于可 用在大多数开发项目中的通用能力和技能。如果您参考本路线图所罗列的相关材料，您将可以为自己创建一 个高效的学习计划，而不被次要信息分心。本路线图将帮助您达到一个许多商业项目普遍要求的C++水平。 详细信息: https://github.com/salmer/CppDeveloperRoadmap
创作者
https://github.com/salmer/CppDeveloperRoadmap
如何使用
反馈与沟通
初学者需注意，对于中级和高 级的技能，只需掌握基本概念 即可。
中级开发者具备以下能力： 可以为一款应用程序设计出 新的功能，即便是缺乏对于 该项新功能的完善的具体要 求或相关信息。
选修
如您有任何意见或建议，请随时与我们联系。我们将感激不尽 :) 您可通过以下任一Github链接联系我们
高级
中级
初级
初学者必须尽快掌握以下技能 : 编写易读且结构良好的代码。
本路线图标示出了学习“步骤”。 这些“步骤”旨在规划出一套 易于操作的学习计划，以帮助 初学者在获取足够的C++基础 知识的同时，逐步提升深入学 习的信心。
高级开发者具备以下能力： 结合业务领域的相关背景， 设计出解决方案/组件，并作 出相关决策。
Text is not SVG - cannot display \ No newline at end of file diff --git a/Chinese/README.md b/Chinese/README.md index 9e63cf6..e75833b 100644 --- a/Chinese/README.md +++ b/Chinese/README.md @@ -1,6 +1,6 @@ # C++ 开发者路线图 -## :speech_balloon: 其他语言：[English](../README.md) [Русский](../Russian/README.md) +## :speech_balloon: 其他语言：[English](../README.md) [Русский](../Russian/README.md) [Español](../Spanish/README.md) C++ 仍然是 [2025 年](https://survey.stackoverflow.co/2025/technology#most-popular-technologies) 中最受欢迎的开发语言之一。有很多人想开始学习 C++ 并成为开发者。他们面临着这些问题：“我应该从哪里开始？我应该按照什么顺序学习？我应该读哪些书？” diff --git a/English/Graph/README.md b/English/Graph/README.md index fb26953..635303a 100644 --- a/English/Graph/README.md +++ b/English/Graph/README.md @@ -20,8 +20,8 @@ that has drifted from it. 1. Fork the repository and edit the source: - a node, its grade/stage, or a hint → `tools/mapgen/roadmap/structure.dsl` - - wording (a label, a hint, the date) → the matching row in `en.tsv` / `ru.tsv` / `zh.tsv` - (a new node needs a row in **all three**). + - wording (a label, a hint, the date) → the matching row in `en.tsv` / `ru.tsv` / `zh.tsv` / `es.tsv` + (a new node needs a row in **all four**). 2. **First time only** — get your machine ready: ```bash python tools/mapgen/setup.py --venv @@ -29,7 +29,7 @@ that has drifted from it. It creates a virtualenv, installs Pillow, and checks for the two things it can't install for you (a CJK font and the draw.io desktop app), printing the exact command for your OS if either is missing. -3. Rebuild, update all three maps and validate — one command from the repo root: +3. Rebuild, update all four maps and validate — one command from the repo root: ```bash python tools/mapgen/build.py --dir tools/mapgen/roadmap --deploy --check ``` diff --git a/English/Graph/roadmap.drawio.svg b/English/Graph/roadmap.drawio.svg index b9bbc38..5c5cf2a 100644 --- a/English/Graph/roadmap.drawio.svg +++ b/English/Graph/roadmap.drawio.svg @@ -1,4 +1,4 @@ -1 step2 step3 step4 step1 step3 step5 step1 step4 step2 stepC++ developerSoft skillsAbility to learnAsk the right questionsProcess informationExperimentingManage knowledgeManage mistakesAnalyze mistakesAdmitting your mistakesNotify about mistakes in timeAccept criticismThinkingLogicalSystemsCriticalCreativeStrategicResponsibilityDisciplinePersistenceInitiativeIndependenceProblem solvingManage resourcesTime managementPrioritizationTaking decisionsBlind typingMultitaskingCommunicationNegotiationAbility to listenPersuasionAbility to communicate ideas and thoughts within the teamProviding information to people outside the teamFinding compromisesDispute resolutionEnglishPresentationWritten communication skillNetworkingTeam workUnderstanding the distribution of roles in a teamSupport team membersWork in a distributed teamProviding feedbackLeadershipAssigning and clarifying tasks to employeesPlanning and goal settingMentoringDelegationEmotional intelligenceStress resistanceWorking in uncertaintyAdaptabilityOpen-mindednessConcentrationEmpathyUnderstanding the development contextCustomer focusTechnologyTrendsHard skillsLanguage syntaxBasic operationsArithmetic operationsLogical operationsLoops: for/whileBitwise operationsFunctionsOperatorslambdaData typesStatic typingDynamic typingRTTIPointers & ReferencesReferencesSmart pointerunique_ptrshared_ptrweak_ptrMemory modelLifetime of objectsRaw pointersnew/delete operatorsMemory leakageCodebase structuringCode splitting into headers/cpp filesForward declarationScopeNamespacesStructures and classesObject Oriented programming (OOP)Static polymorphismOverloading of functionsDynamic polymorphismVirtual methodsVirtual table (vtbl)The rule of zero/three/fiveMultiple inheritanceDiamond inheritanceException handlingstd::optional / std::expectedExceptionsAccess violationnoexceptError codesstd::error_codeLanguage conceptsauto (automatic type deduction)type castingstatic_castconst_castdynamic_castreinterpret_castUndefined Behavior (UB)Argument-dependent lookup (ADL)constexpr / constevalMacrosName manglingMove semanticsValue categories (lvalue/rvalue)std::move / std::forwardPerfect forwardingCoroutines (C++20)Modules (C++20)Standard library + STLiostreamstd::format / std::printDate/timeContainersstd::span / std::string_viewIteratorsAlgorithmsstd::rangesMultithreadingTemplatesVariadic templatesThe template specializationThe full template specializationThe partial template specializationtype traitsSFINAEConcepts (C++20)IdiomsRAIIpimplNon-Copyable/Non-MoveableErase-RemoveCopy and swapCopy on writeCRTPStandardsC++11/14C++17C++20C++23C++26 (newest)Language toolsWorking with source codeText editorsIDECode editorsKnowledge of features and abilities (shortcuts, tools, plugins)DebuggerUnderstanding of debugger messagesDebugging symbolsWinDbgGDBLLDBLintersCompiler Explorer (godbolt.org)CompilersBasic understanding of compilers stagesCompilation of sources to object files (compilation)The object files linkage (linking)Working stages of compilersFeatures of a particular compilerBuild systemsCMakeMakefileninjaPackage managersConannugetvcpkgspackWorking with librariesLibraries inclusionLicensingLibrariesboostopencvpocoprotobufAsiogRPCfmtnlohmann/jsonpybind11spdlogrange-v3tensorflowopenclFrameworksgtest/gmockQtcatch2google benchmarkgoogle profilerpytorch c++Common skillsComputers ScienceData structuresBoolean algebraAlgorithmsFinite-state machinesVersion control softwareDistributedgitMercurialCentralizedSVNBest practicesCode qualityCode guidelinesPrinciples of developmentKISS (Keep It Simple, Stupid)DRY (Don't Repeat Yourself)YAGNI (You Aren't Gonna Need It)APO (Avoid Premature Optimization)BDUF (Big Design Up Front)Composition is preferably than the inheritanceOccam's razorDivide and ConquerLogging and telemetryCode reviewSkill to read existing code sourcesSkill to review codeLifecycle stages of a softwareImplementationTestingUnit testsIntegration testsFunctional testsPerformance testsMaintananceVersioningBackward compatibilitySoftware architecture and components designComponents integrationDeploymentCollecting requirementsEnd of a software lifecycleCode analyzersStatic analyzersDynamic analyzersProfilersValgrindperf / VTuneC++ core guidelinesMicrosoft GSLIndustrial standardsMISRA C++:2023AutosarEU Cyber Resilience Act (CRA)SBOMIEC 62304 (medical)ISO 26262 (automotive)DO-178C (avionics)Command linePowershellbatchbashCI/CDCreation of a software deployment packageDocumentationInstaller packageTrunk Based DevelopmentZero downtime deploymentAI toolsAI assistants (Copilot, Claude Code, Cursor)Verifying generated codeCompany policy and confidentialityLicensing risks of generated codeLocal modelsUsage of other programming languagesLanguage interoperabilitySoftware designDesign Patters (GoF)StructuralBehavioralCreationalOOPSOLIDUMLArchitecture stylesComponent-basedMonolithic applicationLayeredClient-serverMicroservices architectureEvent-drivenPlug-insRESTService-oriented architectureArchitecture patternsMVCMVVMThree-tierOnionHexagonMethodologies of developmentTest Driven DevelopmentBehavior Driven DevelopmentDomain Driven DesignOperating systemsBinary unitsExecutable fileStatic libraryDynamic libraryMemoryMemory abstractionsStackHeapGlobal memoryApplication memoryMemory alignmentMemory managementVirtual memoryThreadsMultithreadingErrorsDead lockRace conditionLive lockStarvationstd::atomic, C++ memory modelConcurrencyMutexesSemaphoreslock-freecondition_variablefuture / promise / asyncjthread (C++20)Event handlingSyncAsyncOpenMP / TBBProcessInterprocess communicationShared memoryPipesSerializationjsonXMLNetworkTCP/IPSocketsTCPUDPHTTPOSIFile systemTask schedulerVirtualizationVirtualBoxVMware WorkstationHyper-VContainersDockerKubernetesCloud ServicesSecurityVulnerabilities: buffer overflow, use-after-freeSanitizers (ASan / TSan / UBSan)EncryptionFuzzingCERT C++ / CWEMultiCPU systemsMulticore CPUNUMAInput/outputDriversAudioDirectSoundOpenALGraphicsDirectXOpenGLVulkanCUDAPrinters (printing)The overloading of regular setof operators for regular orcustom types(structures/classes).To prevent memory leakageproblems it is better to usesmart pointers rather than rawpointers.It's preferred to avoid multipleinheritance (excepting abstractclasses) to prevent runtimeissuesSome of languageconstructions havenon-declared behavioraccording to the ISO standard.In case of any error, it's notpossible to predict furtherbehavior. It depends on aplatform environment, runtimecontext, etc.Ability to gather, analyze,evaluate information andmake decisions based on it.Choose one of the popularIDEs and study it well: MSVisual Studio, VS Code, QtCreator, JetBrains CLion,XCode, etc.Choose one of the populareditors and study it well. Forexample: Notepad++, SublimeText, etc.Choose one of the populareditors and study it well. Forexample: VS Code, SublimeText, Zed, etc.Learn about common errors(segfault, out of memory,access violation) andundefined behavior concept.ReflectionStudy how to use a debuggerand all its featuresThe ability to work with adebugger via command line isa not common skill. It'ssufficient to work with it viaIDE. For example: setconditional breakpoints, etc.Calmly react to what peoplesay. Most likely that they onlyconsider their own contextwhen they try to provesomething. This is fine.Evaluate the usefulness of theirpoint of view.The compiler performs severalstages of code compilation. It'sgood to know about all ofthem to better understandcompilation issues. Deepknowledge is needed forcompiler creators only.Take challenging tasks in orderto develop your skills andcompetencies, even whenthere is not enoughknowledge/experience (skillswill develop much fasterthrough such tasks). The mainthing is to distinguish a reallyuseful complex task that willhelp you to boost your skillsfrom a dumb task thatrequires a scapegoat.Each compiler has its nuances.It's good to know about themto prevent getting any trap:ÂClang++/LLVM, Intel C++,MSVS C++, GCC, MinGWYou should be responsible foryour professionaldevelopment. Don't wait forthe team lead to decide foryou what to study. Do notforget that blind adherence tosomeone else's plan willsharpen your skills accordingto requirements of a particularcompany. It is better toÂdiscuss and build in yourinterests into the plan. If this isnot done, there is a high riskof getting irrelevant skills,which will hit careeropportunities. But don'toverdo it: don't studyabsolutely everything or don'tpassively wait until adevelopment plan will becreated for you.Carefully read the terms of thelicense agreement. Yourproject must comply withthem.Self-organizationThe ability to provide theamount of information that isnecessary to communicate topeople with differentbackgrounds.At first, some of the skills mayseem impossible to develop.However, we think differently.It is possible to work on eachof the skills. Everythingdepends on your desire andinternal blocks. Everything isindividual, and it's up to you todecide. :)Conflict solvingIf you read this it means youalready understand why it is soimportant :) Usually, it isrequired at least to readbecause you would need tounderstand technicaldocumentation. But as youmove up the career ladder,you will need to speak andwrite more confidently inEnglish.Look for like-minded peopleand join/create a communityfor experience exchange.It's also good to know how tocalculate algorithm complexityand memory consumption.You should study and observecontemporary trends to becompetitive, as well as beingable to adapt to them.Experienced developers shoulddevelop management skillsand business communicationskills to complete tasksefficiently. It is easier to do ifyou have developed emotionalintelligence. For a juniordeveloper, the skill is alsouseful to better interact withcolleagues.To configure automated codeformatting verification withone of the suitable utilities:clang-format, Resharper -code style, MSVS - code style.Naming conventions, tabs vsspaces, etc.Do not ignore warnings fromcompiler and static analyzer.They are your friends, notenemiesAI can generate plausible butincorrect code — verify andtest everything. Knowledge ofC++ is required.- Scripting - Functional - SQLlike - NoSQLSometimes it's needed toprovide an ability to reuse alibrary written in a differentlanguage from another one.For example: to call C++libraries in C#.Memory-safety requirementsare rising (US and EUregulators). Learn safepractices and analysis tools.
C++ Developer Roadmap
Last updated: 2026-07-25
About:
C ++ is still one of the most popular development languages. There is quite a number of people that want to start learning it and become a C++ developer. They face questions like: "Where should I start? What and in what order should I study? What books should I read?" We tried to answer these questions in the presented roadmap. The map focuses on general competencies and skills that could be found in most projects. It is designed to help those who are just starting their education or have little experience. You can create a more productive learning plan without being distracted by side information if you study the set of listed materials. It will help you to master C++ at the level that is used in many commercial projects.
Repository:
https://github.com/salmer/CppDeveloperRoadmap
How to use:
Feedback:
The juniors should be aware of middle/senior skills. It's enough to have a basic understanding of them.
The middle developer has the skills to create a design for new functionality as a part of a component/application if even there're not enough requirements or information presented.
Optional
If you have any feedback or remarks don't hesitate to contact us. We really appreciate it. :) To contact us choose one of the following Github approaches: - For any remarks related to repository content - go to Pull Requests and submit a new one
Senior
Middle
Junior
The junior must acquire the following skill as soon as possible: to write easy-readable and well-structured code.
The "steps" are presented on this map. They're intended to show an easy for newbies to be able to get confident base knowledge about the language at the beginning.
The senior developer has the skills to create a design and make decisions for a solution/component taking into account business area context.
Text is not SVG - cannot display \ No newline at end of file +1 step2 step3 step4 step1 step3 step5 step1 step4 step2 stepC++ developerSoft skillsAbility to learnAsk the right questionsProcess informationExperimentingManage knowledgeManage mistakesAnalyze mistakesAdmitting your mistakesNotify about mistakes in timeAccept criticismThinkingLogicalSystemsCriticalCreativeStrategicResponsibilityDisciplinePersistenceInitiativeIndependenceProblem solvingManage resourcesTime managementPrioritizationTaking decisionsBlind typingMultitaskingCommunicationNegotiationAbility to listenPersuasionAbility to communicate ideas and thoughts within the teamProviding information to people outside the teamFinding compromisesDispute resolutionEnglishPresentationWritten communication skillNetworkingTeam workUnderstanding the distribution of roles in a teamSupport team membersWork in a distributed teamProviding feedbackLeadershipAssigning and clarifying tasks to employeesPlanning and goal settingMentoringDelegationEmotional intelligenceStress resistanceWorking in uncertaintyAdaptabilityOpen-mindednessConcentrationEmpathyUnderstanding the development contextCustomer focusTechnologyTrendsHard skillsLanguage syntaxBasic operationsArithmetic operationsLogical operationsLoops: for/whileBitwise operationsFunctionsOperatorslambdaData typesStatic typingDynamic typingRTTIPointers & ReferencesReferencesSmart pointerunique_ptrshared_ptrweak_ptrMemory modelLifetime of objectsRaw pointersnew/delete operatorsMemory leakageCodebase structuringCode splitting into headers/cpp filesForward declarationScopeNamespacesStructures and classesObject Oriented programming (OOP)Static polymorphismOverloading of functionsDynamic polymorphismVirtual methodsVirtual table (vtbl)The rule of zero/three/fiveMultiple inheritanceDiamond inheritanceException handlingstd::optional / std::expectedExceptionsAccess violationnoexceptError codesstd::error_codeLanguage conceptsauto (automatic type deduction)type castingstatic_castconst_castdynamic_castreinterpret_castUndefined Behavior (UB)Argument-dependent lookup (ADL)constexpr / constevalMacrosName manglingMove semanticsValue categories (lvalue/rvalue)std::move / std::forwardPerfect forwardingCoroutines (C++20)Modules (C++20)Standard library + STLiostreamstd::format / std::printDate/timeContainersstd::span / std::string_viewIteratorsAlgorithmsstd::rangesMultithreadingTemplatesVariadic templatesThe template specializationThe full template specializationThe partial template specializationtype traitsSFINAEConcepts (C++20)IdiomsRAIIpimplNon-Copyable/Non-MoveableErase-RemoveCopy and swapCopy on writeCRTPStandardsC++11/14C++17C++20C++23C++26 (newest)Language toolsWorking with source codeText editorsIDECode editorsKnowledge of features and abilities (shortcuts, tools, plugins)DebuggerUnderstanding of debugger messagesDebugging symbolsWinDbgGDBLLDBLintersCompiler Explorer (godbolt.org)CompilersBasic understanding of compilers stagesCompilation of sources to object files (compilation)The object files linkage (linking)Working stages of compilersFeatures of a particular compilerBuild systemsCMakeMakefileninjaPackage managersConannugetvcpkgspackWorking with librariesLibraries inclusionLicensingLibrariesboostopencvpocoprotobufAsiogRPCfmtnlohmann/jsonpybind11spdlogrange-v3tensorflowopenclFrameworksgtest/gmockQtcatch2google benchmarkgoogle profilerpytorch c++Common skillsComputers ScienceData structuresBoolean algebraAlgorithmsFinite-state machinesVersion control softwareDistributedgitMercurialCentralizedSVNBest practicesCode qualityCode guidelinesPrinciples of developmentKISS (Keep It Simple, Stupid)DRY (Don't Repeat Yourself)YAGNI (You Aren't Gonna Need It)APO (Avoid Premature Optimization)BDUF (Big Design Up Front)Composition is preferably than the inheritanceOccam's razorDivide and ConquerLogging and telemetryCode reviewSkill to read existing code sourcesSkill to review codeLifecycle stages of a softwareImplementationTestingUnit testsIntegration testsFunctional testsPerformance testsMaintananceVersioningBackward compatibilitySoftware architecture and components designComponents integrationDeploymentCollecting requirementsEnd of a software lifecycleCode analyzersStatic analyzersDynamic analyzersProfilersValgrindperf / VTuneC++ core guidelinesMicrosoft GSLIndustrial standardsMISRA C++:2023AutosarEU Cyber Resilience Act (CRA)SBOMIEC 62304 (medical)ISO 26262 (automotive)DO-178C (avionics)Command linePowershellbatchbashCI/CDCreation of a software deployment packageDocumentationInstaller packageTrunk Based DevelopmentZero downtime deploymentAI toolsAI assistants (Copilot, Claude Code, Cursor)Verifying generated codeCompany policy and confidentialityLicensing risks of generated codeLocal modelsUsage of other programming languagesLanguage interoperabilitySoftware designDesign Patters (GoF)StructuralBehavioralCreationalOOPSOLIDUMLArchitecture stylesComponent-basedMonolithic applicationLayeredClient-serverMicroservices architectureEvent-drivenPlug-insRESTService-oriented architectureArchitecture patternsMVCMVVMThree-tierOnionHexagonMethodologies of developmentTest Driven DevelopmentBehavior Driven DevelopmentDomain Driven DesignOperating systemsBinary unitsExecutable fileStatic libraryDynamic libraryMemoryMemory abstractionsStackHeapGlobal memoryApplication memoryMemory alignmentMemory managementVirtual memoryThreadsMultithreadingErrorsDead lockRace conditionLive lockStarvationstd::atomic, C++ memory modelConcurrencyMutexesSemaphoreslock-freecondition_variablefuture / promise / asyncjthread (C++20)Event handlingSyncAsyncOpenMP / TBBProcessInterprocess communicationShared memoryPipesSerializationjsonXMLNetworkTCP/IPSocketsTCPUDPHTTPOSIFile systemTask schedulerVirtualizationVirtualBoxVMware WorkstationHyper-VContainersDockerKubernetesCloud ServicesSecurityVulnerabilities: buffer overflow, use-after-freeSanitizers (ASan / TSan / UBSan)EncryptionFuzzingCERT C++ / CWEMultiCPU systemsMulticore CPUNUMAInput/outputDriversAudioDirectSoundOpenALGraphicsDirectXOpenGLVulkanCUDAPrinters (printing)The overloading of regular setof operators for regular orcustom types(structures/classes).To prevent memory leakageproblems it is better to usesmart pointers rather than rawpointers.It's preferred to avoid multipleinheritance (excepting abstractclasses) to prevent runtimeissuesSome of languageconstructions havenon-declared behavioraccording to the ISO standard.In case of any error, it's notpossible to predict furtherbehavior. It depends on aplatform environment, runtimecontext, etc.Ability to gather, analyze,evaluate information andmake decisions based on it.Choose one of the popularIDEs and study it well: MSVisual Studio, VS Code, QtCreator, JetBrains CLion,XCode, etc.Choose one of the populareditors and study it well. Forexample: Notepad++, SublimeText, etc.Choose one of the populareditors and study it well. Forexample: VS Code, SublimeText, Zed, etc.Learn about common errors(segfault, out of memory,access violation) andundefined behavior concept.ReflectionStudy how to use a debuggerand all its featuresThe ability to work with adebugger via command line isa not common skill. It'ssufficient to work with it viaIDE. For example: setconditional breakpoints, etc.Calmly react to what peoplesay. Most likely that they onlyconsider their own contextwhen they try to provesomething. This is fine.Evaluate the usefulness of theirpoint of view.The compiler performs severalstages of code compilation. It'sgood to know about all ofthem to better understandcompilation issues. Deepknowledge is needed forcompiler creators only.Take challenging tasks in orderto develop your skills andcompetencies, even whenthere is not enoughknowledge/experience (skillswill develop much fasterthrough such tasks). The mainthing is to distinguish a reallyuseful complex task that willhelp you to boost your skillsfrom a dumb task thatrequires a scapegoat.Each compiler has its nuances.It's good to know about themto prevent getting any trap:ÂClang++/LLVM, Intel C++,MSVS C++, GCC, MinGWYou should be responsible foryour professionaldevelopment. Don't wait forthe team lead to decide foryou what to study. Do notforget that blind adherence tosomeone else's plan willsharpen your skills accordingto requirements of a particularcompany. It is better toÂdiscuss and build in yourinterests into the plan. If this isnot done, there is a high riskof getting irrelevant skills,which will hit careeropportunities. But don'toverdo it: don't studyabsolutely everything or don'tpassively wait until adevelopment plan will becreated for you.Carefully read the terms of thelicense agreement. Yourproject must comply withthem.Self-organizationThe ability to provide theamount of information that isnecessary to communicate topeople with differentbackgrounds.At first, some of the skills mayseem impossible to develop.However, we think differently.It is possible to work on eachof the skills. Everythingdepends on your desire andinternal blocks. Everything isindividual, and it's up to you todecide. :)Conflict solvingIf you read this it means youalready understand why it is soimportant :) Usually, it isrequired at least to readbecause you would need tounderstand technicaldocumentation. But as youmove up the career ladder,you will need to speak andwrite more confidently inEnglish.Look for like-minded peopleand join/create a communityfor experience exchange.It's also good to know how tocalculate algorithm complexityand memory consumption.You should study and observecontemporary trends to becompetitive, as well as beingable to adapt to them.Experienced developers shoulddevelop management skillsand business communicationskills to complete tasksefficiently. It is easier to do ifyou have developed emotionalintelligence. For a juniordeveloper, the skill is alsouseful to better interact withcolleagues.To configure automated codeformatting verification withone of the suitable utilities:clang-format, Resharper -code style, MSVS - code style.Naming conventions, tabs vsspaces, etc.Do not ignore warnings fromcompiler and static analyzer.They are your friends, notenemiesAI can generate plausible butincorrect code — verify andtest everything. Knowledge ofC++ is required.- Scripting - Functional - SQLlike - NoSQLSometimes it's needed toprovide an ability to reuse alibrary written in a differentlanguage from another one.For example: to call C++libraries in C#.Memory-safety requirementsare rising (US and EUregulators). Learn safepractices and analysis tools.
C++ Developer Roadmap
Last updated: 2026-09-02
About:
C ++ is still one of the most popular development languages. There is quite a number of people that want to start learning it and become a C++ developer. They face questions like: "Where should I start? What and in what order should I study? What books should I read?" We tried to answer these questions in the presented roadmap. The map focuses on general competencies and skills that could be found in most projects. It is designed to help those who are just starting their education or have little experience. You can create a more productive learning plan without being distracted by side information if you study the set of listed materials. It will help you to master C++ at the level that is used in many commercial projects.
Repository:
https://github.com/salmer/CppDeveloperRoadmap
How to use:
Feedback:
The juniors should be aware of middle/senior skills. It's enough to have a basic understanding of them.
The middle developer has the skills to create a design for new functionality as a part of a component/application if even there're not enough requirements or information presented.
Optional
If you have any feedback or remarks don't hesitate to contact us. We really appreciate it. :) To contact us choose one of the following Github approaches: - For any remarks related to repository content - go to Pull Requests and submit a new one
Senior
Middle
Junior
The junior must acquire the following skill as soon as possible: to write easy-readable and well-structured code.
The "steps" are presented on this map. They're intended to show an easy for newbies to be able to get confident base knowledge about the language at the beginning.
The senior developer has the skills to create a design and make decisions for a solution/component taking into account business area context.
Text is not SVG - cannot display \ No newline at end of file diff --git a/README.md b/README.md index 87f3f01..fff6f48 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # C++ Developer Roadmap -## :speech_balloon: Additional languages: [Русский](Russian/README.md) [中文](Chinese/README.md) +## :speech_balloon: Additional languages: [Русский](Russian/README.md) [中文](Chinese/README.md) [Español](Spanish/README.md) C++ is still one of the most popular development languages in [2025](https://survey.stackoverflow.co/2025/technology#most-popular-technologies). There are quite a few people who want to start learning C++ and become a developer. They face the questions: "Where should I start? What and in what order should I study? What books should I read?" diff --git a/Russian/Graph/README.md b/Russian/Graph/README.md index dbf2aab..cde8b65 100644 --- a/Russian/Graph/README.md +++ b/Russian/Graph/README.md @@ -2,7 +2,7 @@ [roadmap.drawio.svg](roadmap.drawio.svg) — это обычное SVG-изображение со встроенной диаграммой [draw.io](https://www.drawio.com): откройте его где угодно, чтобы увидеть карту. Но это -**сгенерированный** файл: настоящий исходник — это языконезависимое текстовое описание в +**сгенерированный** файл: настоящий исходник — это единое текстовое описание, общее для всех языков, в [`tools/mapgen/roadmap/`](../../tools/mapgen/roadmap), а этот `.drawio.svg` является результатом сборки, а не тем, что вы правите. @@ -21,8 +21,8 @@ 1. Сделайте форк и правьте исходник: - узел, его грейд/этап или подсказка → `tools/mapgen/roadmap/structure.dsl` - - текст (подпись, подсказка, дата) → соответствующая строка в `en.tsv` / `ru.tsv` / `zh.tsv` - (новому узлу нужна строка **во всех трёх**). + - текст (подпись, подсказка, дата) → соответствующая строка в `en.tsv` / `ru.tsv` / `zh.tsv` / `es.tsv` + (новому узлу нужна строка **во всех четырёх**). 2. **Только в первый раз** — подготовьте окружение: ```bash python tools/mapgen/setup.py --venv @@ -30,7 +30,7 @@ Скрипт создаёт виртуальное окружение, ставит Pillow и проверяет то, что он установить не может (CJK-шрифт и десктопное приложение draw.io), подсказывая точную команду для вашей ОС. -3. Пересоберите, обновите все три карты и проверьте их — одной командой из корня +3. Пересоберите, обновите все четыре карты и проверьте их — одной командой из корня репозитория: ```bash python tools/mapgen/build.py --dir tools/mapgen/roadmap --deploy --check diff --git a/Russian/Graph/roadmap.drawio.svg b/Russian/Graph/roadmap.drawio.svg index 6a5f8fe..2b80651 100644 --- a/Russian/Graph/roadmap.drawio.svg +++ b/Russian/Graph/roadmap.drawio.svg @@ -1,4 +1,4 @@ -1 этап2 этап3 этап4 этап1 этап3 этап5 этап1 этап4 этап2 этапC++ developerSoft skillsУмение учитьсяУмение задавать правильные вопросыРабота с информациейЭкспериментированиеУправление знаниямиРабота с ошибкамиАнализ ошибокПризнание своих ошибокСвоевременное сигнализирование об ошибкахВосприятие критикиМышлениеЛогическоеСистемноеКритическоеКреативноеСтратегическоеОтветственностьДисциплинаУпорствоИнициативностьСамостоятельностьРешение проблемУправление ресурсамиТайм-менеджментПриоритизацияПринятие решенийСлепая печатьМногозадачностьКоммуникацияПереговорные навыкиУмение слушатьУбеждениеУмение доносить мысль/идеи внутри командыПодача информации людям вне командыПоиск компромиссовРегулирование споровАнглийский языкПрезентацияНавык перепискиНетворкингКомандная работаПонимание распределения ролей в командеПомощьРабота в распределённой командеПредоставление обратной связиЛидерствоПостановка задач сотрудникамПланирование и целеполаганиеНаставничествоДелегированиеЭмоциональный интеллектСтрессоустойчивостьРабота в неопределённостиАдаптируемостьОткрытость новомуКонцентрацияЭмпатияПонимание контекста разработкиКлиентоориентированностьТехнологииТрендыHard skillsСинтаксис языкаБазовые операцииАрифметические операцииЛогические операцииЦиклы for/whileБитовые операцииФункцииОператорыlambdaТипы данныхСтатическая типизацияДинамическая типизацияRTTIУказатели и ссылкиСсылкиУмные указателиunique_ptrshared_ptrweak_ptrМодель памятиВремя жизниСырые УказателиОператоры new/deleteУтечки памятиОрганизация кодовой базыРазделение кода на headers/cpp юнитыForward declarationОбласть видимостиПространство имёнСтруктуры и классыООПСтатический полиморфизмПерегрузка методовДинамический полиморфизмВиртуальные методыТаблица виртуальных методовПравило нуля/трех/пятиМножественное наследованиеРомбовидное наследованиеОбработка ошибокstd::optional / std::expectedИсключенияAccess violationnoexceptКоды возвратаstd::error_codeКонцепции языкаauto (автоматическое выведение типов)type castingstatic_castconst_castdynamic_castreinterpret_castНеопределённое поведение (Undefined Behavior)Поиск, зависящий от аргумента (ADL)constexpr / constevalМакросыName manglingMove-семантикаКатегории значений (lvalue/rvalue)std::move / std::forwardPerfect forwardingCoroutines (C++20)Modules (C++20)Стандартная библиотека + STLПоток ввода/выводаstd::format / std::printДата/времяКонтейнерыstd::span / std::string_viewИтераторыАлгоритмы стандартной библиотекиstd::rangesМногопоточностьШаблоныVariadic templatesСпециализация шаблонаПолная специализацияЧастичная специализацияtype traitsSFINAEConcepts (C++20)ИдиомыRAIIpimplNon-Copyable/Non-MoveableErase-RemoveCopy and swapCopy on writeCRTPСтандартыC++11/14C++17C++20C++23C++26 (newest)Языковые инструментыРабота с исходным кодомТекстовый редакторIDEРедакторы исходного кодаЗнание о базовых возможностях (shortcuts, tools, plugins)ОтладчикУмение читать сообщения отладчикаОтладочные символыWinDbgGDBLLDBЛинтерыCompiler Explorer (godbolt.org)КомпиляторыБазовые знания работы компиляторовКомпиляция кода в объектные файлыКомпоновка объектных файлов в приложение (линковка)Этапы работы компилятораОсобенности работы конкретного компилятораСистемы сборкиCMakeMakefileninjaПакетные менеджерыConannugetvcpkgspackВзаимодействие с библиотекамиПодключение библиотекЛицензированиеПопулярные библиотекиboostopencvpocoprotobufAsiogRPCfmtnlohmann/jsonpybind11spdlogrange-v3tensorflowopenclФреймворкиgtest/gmockQtcatch2google benchmarkgoogle profilerpytorch c++Общие навыкиИнформатикаСтруктуры данныхБулева алгебраАлгоритмыКонечные автоматыСистемы контроля версийРаспределенныеgitMercurialЦентрализованныеSVNПрактики разработкиКачество кодаПравила оформления кодаПринципы разработкиKISS (Keep It Simple, Stupid)DRY (Don't Repeat Yourself)YAGNI (You Aren't Gonna Need It)APO (Avoid Premature Optimization)BDUF (Big Design Up Front)Композиция предпочтительнее наследованияБритва ОккамаРазделяй и властвуйЛогирование и телеметрияРевью кодаУмение читать чужой кодРевью чужого кодаПонимание жизненного цикла производства ПОРеализацияТестированиеЮнит тестыИнтеграционноеФункциональноеПроизводительностьПоддержкаВерсионирование ПООбратная совместимостьФормирование архитектуры и дизайн компонентовИнтеграция компонентовВыпускСбор требованийОкончание жизненного циклаАнализаторы кодаСтатическиеДинамическиеПрофайлерыValgrindperf / VTuneC++ core guidelinesMicrosoft GSLПромышленные стандартыMISRA C++:2023AutosarEU Cyber Resilience Act (CRA)SBOMIEC 62304 (медицина)ISO 26262 (автомобили)DO-178C (авиация)Работа с командной строкойPowershellbatchbashCI/CDСоздание пакета поставки ПОДокументацияИнсталляторTrunk Based DevelopmentZero downtime deploymentAI-инструментыAI-ассистенты (Copilot, Claude Code, Cursor)Верификация сгенерированного кодаПолитика компании и конфиденциальностьЛицензионные риски генерируемого кодаЛокальные моделиИспользование других языков программированияМежязыковое взаимодействиеПроектирование ПОПаттерны проектирования (GoF)СтруктурныеПоведенческиеПорождающиеООПSOLIDUMLАрхитектурные стилиComponent-basedMonolithic applicationLayeredClient-serverMicroservices architectureEvent-drivenPlug-insRESTService-oriented architectureАрхитектурные паттерныMVCMVVMThree-tierOnionHexagonМетодологииTest Driven DevelopmentBehavior Driven DevelopmentDomain Driven DesignОперационные системыБинарные единицыИсполняемый файлСтатическая библиотекаДинамическая библиотекаПамятьАбстракции памятиСтекКучаГлобальная памятьПамять приложенияВыравнивание памятиУправление памятьюВиртуальная памятьПотокиМногопоточностьОшибкиDead lockRace conditionLive lockStarvationstd::atomic, модель памяти C++КонкуренцияМьютексыСемафорыАлгоритмы без блокировок (lock-free)condition_variablefuture / promise / asyncjthread (C++20)Обработка событийСинхронныеАсинхронныеOpenMP / TBBПроцессыМежпроцессное взаимодействиеShared memoryPipesСериализацияjsonXMLСетевой стекTCP/IPСокетыTCPUDPHTTPOSIФайловая системаПланировщикВиртуализацияVirtualBoxVMware WorkstationHyper-VКонтейнеризацияDockerKubernetesОблачные сервисыБезопасностьУязвимости: buffer overflow, use-after-freeСанитайзеры (ASan / TSan / UBSan)ШифрованиеFuzzingCERT C++ / CWEМногопроцессорные системыMulticore CPUNUMAВвод и вывод информацииДрайверыАудиоDirectSoundOpenALГрафическое вычисление/отображениеDirectXOpenGLVulkanCUDAПечатьПерегрузка стандартныхоператоров для различныхтипов/структур/классов.Чтобы избежать проблем суправлением памятью,старайтесь писать кодиспользуя ссылки и умныеуказатели.Не используйтемножественноенаследованиеЯзыковые конструкции длякоторых отсутствуютпрописанные требования встандартах. В случае ошибкидальнейшее поведениебудет предсказатьневозможно, и всецелобудет зависеть от контекставыполнения илиплатформы, где запущеноприложение.Умение собиратьинформацию,анализировать её ивыдавать взвешенноерешение.Выберите один изпонравившихся популярныхIDE и хорошо освойте его:MS Visual Studio, VS Code, QtCreator, JetBrains CLion,XCode и т.д.Выберите один изпопулярных редакторов ихорошо освойте его. Кпримеру: Notepad++,Sublime Text и т.д.Выберите один изпопулярных редакторов ихорошо освойте его: VSCode, Sublime Text, Zed и т.д.Ознакомьтесь с самымираспространённымиошибками (segfault, out ofmemory, access violation) иконцепциейнеопределённого поведения(undefined behavior)РефлексияНаучитесь пользоватьсяотладчиком. Изучите еговозможности.Навык работы с отладчикомчерез командную строку -узконаправленный навык. Врегулярной работедостаточно уметь работать сотладчиком в рамках IDE.Спокойно реагировать на то,что люди говорят. Скореевсего, они учитывают толькособственный контекст, когдачто-то пытаются доказать.Это нормально. Оценивайтеполезность их точки зрения.Есть несколько этаповработы компилятора, окоторых следует знать. Этопомогает решать проблемыпри сборке приложения.Достаточно иметь базовоепонимание, чтобы решатьбольшую часть проблем.Детали работы важныразработчикамкомпиляторов.Брать сложные задачи,чтобы развивать своинавыки и компетенции,даже когда недостаточнознаний/опыта (через такиезадачи гораздо быстрееразвиваются навыки).Главное отличить реальнополезную сложную задачу,которая прокачает, отзадачи, на которую ищуткрайнего.У компиляторов есть своиособенности, о которыххорошо бы знать:Clang++/LLVM, Intel C++,MSVS C++, GCC, MinGWБыть ответственным запрофессиональноеразвитие. Не ждать покатимлид решит, что изучать.Не стоит забывать, чтослепое следование чужомуплану заточит под задачиконкретной компании. Стоитобсуждать и встраивать своиинтересы в план. Если этогоне сделать - высокий рискполучить "непереносимые"компетенции, что ударит покарьерным возможностям.Но и не стоит ударяться вкрайности: изучатьабсолютно всё подряд илипассивно ждать, покавыдадут план развития.Внимательно читайтеусловия лицензионногосоглашения. Ваш проектдолжен их соблюдать.СамоорганизацияСпособность предоставлятьтот объем информации,который необходим дляобщения с людьми разногобекграунда.Сначала может показаться,что некоторые из навыковразвивать невозможно.Однако мы считаем иначе.Над каждым из пунктоввозможно работать. Всёупирается в желание ивнутренние блоки. Всёиндивидуально, и зависит отвас. :)Решение конфликтовДостаточно уверенногочтения документации истатей, но для болееперспективных вакансийразговорный/письменныйнавык становитсяобязательным.Искать единомышленникови присоединяться/создаватькомьюнити для общения ипередачи опыта.Также необходимопонимать, как вычислитьсложность и потреблениепамяти у алгоритмов.Чтобы бытьконкурентоспособным,стоит изучать и наблюдатьза новыми веяниями, атакже уметь адаптироватьсяпод них.Опытному разработчикустоит развивать навыкиуправления и общения сбизнесом для эффективноговыполнения задач. Это легчеделать, если развитэмоциональный интеллект.Для джуниора навык такжеполезен, чтобы лучшевзаимодействовать сколлегами.Настроить форматированиеи автоматически проверятьв одной из утилит:clang-format, Resharper -стиль кода, MSVS - стилькода.Правила именованияпеременных, пробелы vsтабы, положение фигурныхскобок и т.д.Не игнорируйтепредупреждениякомпилятора и статическогоанализатора. Они вамдрузья, а не врагиAI может генерироватьправдоподобный, ноневерный код —проверяйте и тестируйтевсё. Знание C++необходимо.- Скриптовые -Функциональные - SQL like -NoSQLИногда требуетсяпредоставить обертку кбиблиотеке, написанной наC++ для другого ЯП,например Python или C#.Для этого применяютспециальныебиблиотеки/фреймворки.Требования к memory safetyрастут (регуляторы США иЕС). Изучайте безопасныепрактики и инструментыанализа.
C++ Developer Roadmap
Последнее обновление: 21.07.2026
О карте:
С++ всё ещё является одним из самых популярных языков разработки. Есть немало желающих начать его изучать и стать C++ разработчиками. Перед такими людьми встают вопросы: "С чего мне начать? Что и в каком порядке мне изучать? Какие книги стоит почитать?" Мы попытались ответить на эти вопросы в представленной дорожной карте. Карта акцентируется на общих компетенциях и навыках, которые встречаются в большинстве проектов. Она призвана помочь тем, кто только начинает свое обучение или имеет небольшой опыт. Изучив набор перечисленных материалов, вы сможете составить более продуктивный план обучения, не отвлекаясь на побочную информацию. Это поможет вам освоить C++ на том уровне, который встречается во многих коммерческих проектах.
Репозиторий:
https://github.com/salmer/CppDeveloperRoadmap
Как ориентироваться:
Предложения и замечания:
От джуниора ожидается осведомленность про категории, которые относятся к Middle/Senior. Будет достаточным поверхностное понимание темы.
Мидл способен создать дизайн и решения для функционала внутри компонента/приложения даже в случае неполноты требований.
Optional
Если у вас есть замечания, вопросы или предложения, будем рады получить любую помощь и поддержку. Мы открыты для общения :) Для этого используйте следующие механизмы Github: - Предложения/правки по репозиторию - создавайте и присылайте новый PR в Pull Requests
Senior
Middle
Junior
Джуниору важно научиться писать структурированный код и не усложнять его без надобности. Код должен быть легко читаемым и поддерживаемым.
На карте представлены компетенции, которые выделены в "этапы". Мы считаем, что джуниору стоит начинать изучение в данном порядке, чтобы выстроить прочный фундамент.
Синиор способен создать дизайн и решение для компонента/приложения с учётом бизнес-контекста.
Text is not SVG - cannot display \ No newline at end of file +1 этап2 этап3 этап4 этап1 этап3 этап5 этап1 этап4 этап2 этапC++ developerSoft skillsУмение учитьсяУмение задавать правильные вопросыРабота с информациейЭкспериментированиеУправление знаниямиРабота с ошибкамиАнализ ошибокПризнание своих ошибокСвоевременное сигнализирование об ошибкахВосприятие критикиМышлениеЛогическоеСистемноеКритическоеКреативноеСтратегическоеОтветственностьДисциплинаУпорствоИнициативностьСамостоятельностьРешение проблемУправление ресурсамиТайм-менеджментПриоритизацияПринятие решенийСлепая печатьМногозадачностьКоммуникацияПереговорные навыкиУмение слушатьУбеждениеУмение доносить мысль/идеи внутри командыПодача информации людям вне командыПоиск компромиссовРегулирование споровАнглийский языкПрезентацияНавык перепискиНетворкингКомандная работаПонимание распределения ролей в командеПомощьРабота в распределённой командеПредоставление обратной связиЛидерствоПостановка задач сотрудникамПланирование и целеполаганиеНаставничествоДелегированиеЭмоциональный интеллектСтрессоустойчивостьРабота в неопределённостиАдаптируемостьОткрытость новомуКонцентрацияЭмпатияПонимание контекста разработкиКлиентоориентированностьТехнологииТрендыHard skillsСинтаксис языкаБазовые операцииАрифметические операцииЛогические операцииЦиклы for/whileБитовые операцииФункцииОператорыlambdaТипы данныхСтатическая типизацияДинамическая типизацияRTTIУказатели и ссылкиСсылкиУмные указателиunique_ptrshared_ptrweak_ptrМодель памятиВремя жизниСырые УказателиОператоры new/deleteУтечки памятиОрганизация кодовой базыРазделение кода на headers/cpp юнитыForward declarationОбласть видимостиПространство имёнСтруктуры и классыООПСтатический полиморфизмПерегрузка методовДинамический полиморфизмВиртуальные методыТаблица виртуальных методовПравило нуля/трех/пятиМножественное наследованиеРомбовидное наследованиеОбработка ошибокstd::optional / std::expectedИсключенияAccess violationnoexceptКоды возвратаstd::error_codeКонцепции языкаauto (автоматическое выведение типов)type castingstatic_castconst_castdynamic_castreinterpret_castНеопределённое поведение (Undefined Behavior)Поиск, зависящий от аргумента (ADL)constexpr / constevalМакросыName manglingMove-семантикаКатегории значений (lvalue/rvalue)std::move / std::forwardPerfect forwardingCoroutines (C++20)Modules (C++20)Стандартная библиотека + STLПоток ввода/выводаstd::format / std::printДата/времяКонтейнерыstd::span / std::string_viewИтераторыАлгоритмы стандартной библиотекиstd::rangesМногопоточностьШаблоныVariadic templatesСпециализация шаблонаПолная специализацияЧастичная специализацияtype traitsSFINAEConcepts (C++20)ИдиомыRAIIpimplNon-Copyable/Non-MoveableErase-RemoveCopy and swapCopy on writeCRTPСтандартыC++11/14C++17C++20C++23C++26 (newest)Языковые инструментыРабота с исходным кодомТекстовый редакторIDEРедакторы исходного кодаЗнание о базовых возможностях (shortcuts, tools, plugins)ОтладчикУмение читать сообщения отладчикаОтладочные символыWinDbgGDBLLDBЛинтерыCompiler Explorer (godbolt.org)КомпиляторыБазовые знания работы компиляторовКомпиляция кода в объектные файлыКомпоновка объектных файлов в приложение (линковка)Этапы работы компилятораОсобенности работы конкретного компилятораСистемы сборкиCMakeMakefileninjaПакетные менеджерыConannugetvcpkgspackВзаимодействие с библиотекамиПодключение библиотекЛицензированиеПопулярные библиотекиboostopencvpocoprotobufAsiogRPCfmtnlohmann/jsonpybind11spdlogrange-v3tensorflowopenclФреймворкиgtest/gmockQtcatch2google benchmarkgoogle profilerpytorch c++Общие навыкиИнформатикаСтруктуры данныхБулева алгебраАлгоритмыКонечные автоматыСистемы контроля версийРаспределенныеgitMercurialЦентрализованныеSVNПрактики разработкиКачество кодаПравила оформления кодаПринципы разработкиKISS (Keep It Simple, Stupid)DRY (Don't Repeat Yourself)YAGNI (You Aren't Gonna Need It)APO (Avoid Premature Optimization)BDUF (Big Design Up Front)Композиция предпочтительнее наследованияБритва ОккамаРазделяй и властвуйЛогирование и телеметрияРевью кодаУмение читать чужой кодРевью чужого кодаПонимание жизненного цикла производства ПОРеализацияТестированиеЮнит тестыИнтеграционноеФункциональноеПроизводительностьПоддержкаВерсионирование ПООбратная совместимостьФормирование архитектуры и дизайн компонентовИнтеграция компонентовВыпускСбор требованийОкончание жизненного циклаАнализаторы кодаСтатическиеДинамическиеПрофайлерыValgrindperf / VTuneC++ core guidelinesMicrosoft GSLПромышленные стандартыMISRA C++:2023AutosarEU Cyber Resilience Act (CRA)SBOMIEC 62304 (медицина)ISO 26262 (автомобили)DO-178C (авиация)Работа с командной строкойPowershellbatchbashCI/CDСоздание пакета поставки ПОДокументацияИнсталляторTrunk Based DevelopmentZero downtime deploymentAI-инструментыAI-ассистенты (Copilot, Claude Code, Cursor)Верификация сгенерированного кодаПолитика компании и конфиденциальностьЛицензионные риски генерируемого кодаЛокальные моделиИспользование других языков программированияМежязыковое взаимодействиеПроектирование ПОПаттерны проектирования (GoF)СтруктурныеПоведенческиеПорождающиеООПSOLIDUMLАрхитектурные стилиComponent-basedMonolithic applicationLayeredClient-serverMicroservices architectureEvent-drivenPlug-insRESTService-oriented architectureАрхитектурные паттерныMVCMVVMThree-tierOnionHexagonМетодологииTest Driven DevelopmentBehavior Driven DevelopmentDomain Driven DesignОперационные системыБинарные единицыИсполняемый файлСтатическая библиотекаДинамическая библиотекаПамятьАбстракции памятиСтекКучаГлобальная памятьПамять приложенияВыравнивание памятиУправление памятьюВиртуальная памятьПотокиМногопоточностьОшибкиDead lockRace conditionLive lockStarvationstd::atomic, модель памяти C++КонкуренцияМьютексыСемафорыАлгоритмы без блокировок (lock-free)condition_variablefuture / promise / asyncjthread (C++20)Обработка событийСинхронныеАсинхронныеOpenMP / TBBПроцессыМежпроцессное взаимодействиеShared memoryPipesСериализацияjsonXMLСетевой стекTCP/IPСокетыTCPUDPHTTPOSIФайловая системаПланировщикВиртуализацияVirtualBoxVMware WorkstationHyper-VКонтейнеризацияDockerKubernetesОблачные сервисыБезопасностьУязвимости: buffer overflow, use-after-freeСанитайзеры (ASan / TSan / UBSan)ШифрованиеFuzzingCERT C++ / CWEМногопроцессорные системыMulticore CPUNUMAВвод и вывод информацииДрайверыАудиоDirectSoundOpenALГрафическое вычисление/отображениеDirectXOpenGLVulkanCUDAПечатьПерегрузка стандартныхоператоров для различныхтипов/структур/классов.Чтобы избежать проблем суправлением памятью,старайтесь писать кодиспользуя ссылки и умныеуказатели.Не используйтемножественноенаследованиеЯзыковые конструкции длякоторых отсутствуютпрописанные требования встандартах. В случае ошибкидальнейшее поведениебудет предсказатьневозможно, и всецелобудет зависеть от контекставыполнения илиплатформы, где запущеноприложение.Умение собиратьинформацию,анализировать её ивыдавать взвешенноерешение.Выберите один изпонравившихся популярныхIDE и хорошо освойте его:MS Visual Studio, VS Code, QtCreator, JetBrains CLion,XCode и т.д.Выберите один изпопулярных редакторов ихорошо освойте его. Кпримеру: Notepad++,Sublime Text и т.д.Выберите один изпопулярных редакторов ихорошо освойте его: VSCode, Sublime Text, Zed и т.д.Ознакомьтесь с самымираспространённымиошибками (segfault, out ofmemory, access violation) иконцепциейнеопределённого поведения(undefined behavior)РефлексияНаучитесь пользоватьсяотладчиком. Изучите еговозможности.Навык работы с отладчикомчерез командную строку -узконаправленный навык. Врегулярной работедостаточно уметь работать сотладчиком в рамках IDE.Спокойно реагировать на то,что люди говорят. Скореевсего, они учитывают толькособственный контекст, когдачто-то пытаются доказать.Это нормально. Оценивайтеполезность их точки зрения.Есть несколько этаповработы компилятора, окоторых следует знать. Этопомогает решать проблемыпри сборке приложения.Достаточно иметь базовоепонимание, чтобы решатьбольшую часть проблем.Детали работы важныразработчикамкомпиляторов.Брать сложные задачи,чтобы развивать своинавыки и компетенции,даже когда недостаточнознаний/опыта (через такиезадачи гораздо быстрееразвиваются навыки).Главное отличить реальнополезную сложную задачу,которая прокачает, отзадачи, на которую ищуткрайнего.У компиляторов есть своиособенности, о которыххорошо бы знать:Clang++/LLVM, Intel C++,MSVS C++, GCC, MinGWБыть ответственным запрофессиональноеразвитие. Не ждать покатимлид решит, что изучать.Не стоит забывать, чтослепое следование чужомуплану заточит под задачиконкретной компании. Стоитобсуждать и встраивать своиинтересы в план. Если этогоне сделать - высокий рискполучить "непереносимые"компетенции, что ударит покарьерным возможностям.Но и не стоит ударяться вкрайности: изучатьабсолютно всё подряд илипассивно ждать, покавыдадут план развития.Внимательно читайтеусловия лицензионногосоглашения. Ваш проектдолжен их соблюдать.СамоорганизацияСпособность предоставлятьтот объем информации,который необходим дляобщения с людьми разногобекграунда.Сначала может показаться,что некоторые из навыковразвивать невозможно.Однако мы считаем иначе.Над каждым из пунктоввозможно работать. Всёупирается в желание ивнутренние блоки. Всёиндивидуально, и зависит отвас. :)Решение конфликтовДостаточно уверенногочтения документации истатей, но для болееперспективных вакансийразговорный/письменныйнавык становитсяобязательным.Искать единомышленникови присоединяться/создаватькомьюнити для общения ипередачи опыта.Также необходимопонимать, как вычислитьсложность и потреблениепамяти у алгоритмов.Чтобы бытьконкурентоспособным,стоит изучать и наблюдатьза новыми веяниями, атакже уметь адаптироватьсяпод них.Опытному разработчикустоит развивать навыкиуправления и общения сбизнесом для эффективноговыполнения задач. Это легчеделать, если развитэмоциональный интеллект.Для джуниора навык такжеполезен, чтобы лучшевзаимодействовать сколлегами.Настроить форматированиеи автоматически проверятьв одной из утилит:clang-format, Resharper -стиль кода, MSVS - стилькода.Правила именованияпеременных, пробелы vsтабы, положение фигурныхскобок и т.д.Не игнорируйтепредупреждениякомпилятора и статическогоанализатора. Они вамдрузья, а не врагиAI может генерироватьправдоподобный, ноневерный код —проверяйте и тестируйтевсё. Знание C++необходимо.- Скриптовые -Функциональные - SQL like -NoSQLИногда требуетсяпредоставить обертку кбиблиотеке, написанной наC++ для другого ЯП,например Python или C#.Для этого применяютспециальныебиблиотеки/фреймворки.Требования к memory safetyрастут (регуляторы США иЕС). Изучайте безопасныепрактики и инструментыанализа.
C++ Developer Roadmap
Последнее обновление: 2026-09-02
О карте:
С++ всё ещё является одним из самых популярных языков разработки. Есть немало желающих начать его изучать и стать C++ разработчиками. Перед такими людьми встают вопросы: "С чего мне начать? Что и в каком порядке мне изучать? Какие книги стоит почитать?" Мы попытались ответить на эти вопросы в представленной дорожной карте. Карта акцентируется на общих компетенциях и навыках, которые встречаются в большинстве проектов. Она призвана помочь тем, кто только начинает свое обучение или имеет небольшой опыт. Изучив набор перечисленных материалов, вы сможете составить более продуктивный план обучения, не отвлекаясь на побочную информацию. Это поможет вам освоить C++ на том уровне, который встречается во многих коммерческих проектах.
Репозиторий:
https://github.com/salmer/CppDeveloperRoadmap
Как ориентироваться:
Предложения и замечания:
От джуниора ожидается осведомленность про категории, которые относятся к Middle/Senior. Будет достаточным поверхностное понимание темы.
Мидл способен создать дизайн и решения для функционала внутри компонента/приложения даже в случае неполноты требований.
Optional
Если у вас есть замечания, вопросы или предложения, будем рады получить любую помощь и поддержку. Мы открыты для общения :) Для этого используйте следующие механизмы Github: - Предложения/правки по репозиторию - создавайте и присылайте новый PR в Pull Requests
Senior
Middle
Junior
Джуниору важно научиться писать структурированный код и не усложнять его без надобности. Код должен быть легко читаемым и поддерживаемым.
На карте представлены компетенции, которые выделены в "этапы". Мы считаем, что джуниору стоит начинать изучение в данном порядке, чтобы выстроить прочный фундамент.
Синиор способен создать дизайн и решение для компонента/приложения с учётом бизнес-контекста.
Text is not SVG - cannot display \ No newline at end of file diff --git a/Russian/README.md b/Russian/README.md index 433fd87..1c8ae5a 100644 --- a/Russian/README.md +++ b/Russian/README.md @@ -1,6 +1,6 @@ # C++ Developer Roadmap -## :speech_balloon: Другие языки: [English](../README.md) [中文](../Chinese/README.md) +## :speech_balloon: Другие языки: [English](../README.md) [中文](../Chinese/README.md) [Español](../Spanish/README.md) С++ является одним из самых популярных языков разработки: [2025](https://survey.stackoverflow.co/2025/technology#most-popular-technologies). Есть немало желающих начать его изучать и стать C++ разработчиками. Перед такими людьми встают вопросы: "С чего мне начать? Что и в каком порядке мне изучать? Какие книги стоит почитать?" diff --git a/Spanish/AI.md b/Spanish/AI.md new file mode 100644 index 0000000..5b0a71a --- /dev/null +++ b/Spanish/AI.md @@ -0,0 +1,80 @@ +# :robot: El desarrollador de C++ y la inteligencia artificial + +Con la llegada de modelos que escriben código con confianza, muchos aspirantes a desarrolladores se han hecho una pregunta razonable: ¿siquiera vale la pena ingresar a la profesión? Es una pregunta justa, y descartarla con un "nah, todo será igual que antes" sería incorrecto. Veamos qué está pasando realmente. + +La respuesta corta: los ingenieros siguen siendo necesarios, pero el estándar ha cambiado. He aquí por qué. + +## :dna: La IA reproduce aquello con lo que fue entrenada + +Un modelo se entrena en un vasto cuerpo de código ya escrito y, por su propia naturaleza, produce lo que apareció con mayor frecuencia en esos datos. Hace un trabajo excelente con tareas que la humanidad ya ha resuelto miles de veces: analizar JSON, levantar un servidor HTTP, escribir pruebas para una función fácil de entender. + +Sus limitaciones crecen exactamente de la misma raíz: + +- **Lo inusual se maneja mal.** Tu dominio del problema, tus limitaciones de hardware, la compensación (trade-off) entre memoria y latencia en tu caso particular: nada de eso estaba en los datos de entrenamiento. Y el trabajo de ingeniería consiste en gran parte en estas situaciones de "pero en nuestro caso todo es diferente". +- **Un sesgo hacia el código antiguo.** El C++ de código abierto (open-source) se ha acumulado durante décadas y está escrito predominantemente en un estilo antiguo. Por lo tanto, los modelos te entregan felizmente `new`/`delete` en lugar de punteros inteligentes, bucles crudos en lugar de algoritmos, cadenas de C (C-strings) en lugar de `std::string_view`. El código funcionará, pero no será el código que querrás ver en tu proyecto. +- **Confianza no es corrección.** Un modelo puede citar una función de la biblioteca estándar inexistente o confundir el comportamiento de una sobrecarga, y lo afirmará exactamente en el mismo tono que una respuesta correcta. + +## :warning: Por qué el costo de un error es mayor en C++ + +En los lenguajes con memoria administrada, el código incorrecto generalmente falla de forma ruidosa e inmediata. En C++ este no es el caso. + +- **El comportamiento indefinido puede no aparecer en las pruebas.** Una condición de carrera (data race), el acceso a memoria liberada, un acceso a un arreglo fuera de los límites: todo esto puede funcionar "bien" en tu máquina durante años y luego explotar en la máquina de un usuario o después de una actualización del compilador. Ninguna prueba garantiza que el código generado esté libre de ellos. +- **El tiempo de vida de un objeto es el punto más complicado.** Aquí es exactamente donde los modelos se equivocan más a menudo: devuelven una referencia a un objeto local, capturan una variable en una lambda por referencia y no se detienen a pensar quién es el propietario del objeto. +- **Concurrencia.** El código que parece correcto puede contener una condición de carrera que se reproduce una vez a la semana bajo carga. + +La conclusión es simple: **solo puedes aceptar código que seas capaz de verificar**. Y para verificar el código en C++, necesitas saber C++ no menos que cuando lo escribes a mano. Las herramientas que ayudan (sanitizers, static analyzers, fuzzing) se describen en [Conjunto de herramientas del lenguaje](Tooling.md). + +## :bulb: El cuello de botella del desarrollo no es la velocidad de escritura + +Este es el punto más importante. El trabajo de un ingeniero nunca se ha reducido a escribir caracteres. Consiste en: + +- descubrir qué es lo que realmente necesita el cliente (por lo general, tampoco lo entienden bien a la primera); +- decidir qué errores en el sistema **no deben** ocurrir y qué hacer cuando ocurren de todos modos; +- compensaciones (trade-offs): velocidad versus legibilidad, plazos versus deuda técnica, confiabilidad versus costo; +- ser responsable del resultado. + +Ninguna de estas tareas puede delegarse a un modelo, no porque "no sea lo suficientemente inteligente", sino porque son preguntas sobre personas, dinero y responsabilidad. Si una aplicación perjudica a un usuario, es la empresa y los ingenieros específicos quienes responden por ella, no la herramienta. En campos donde el software está certificado —medicina, aviónica, automotriz (ver [Estándares de codificación y requisitos normativos](Compliance.md))— esto ya no es filosofía, sino un requisito literal: un humano firma el resultado. + +Otra observación, conocida mucho antes de las redes neuronales: **leer el código de otra persona es más difícil que escribir el tuyo propio**. A medida que hay más código y se escribe más rápido, el cuello de botella ya no es escribir, sino comprender y revisar. Ese es un trabajo para un ingeniero, y es más probable que su volumen crezca. + +## :chart_with_upwards_trend: Qué cambia realmente + +Sería deshonesto decir que no está pasando nada. Algo está pasando, y esto es lo que ya es visible: + +- **La rutina pierde su valor.** La capacidad de escribir rápidamente otra clase repetitiva (boilerplate) ya no es una ventaja en sí misma. +- **Crece el valor de la verificación y el pensamiento sistémico.** La capacidad de notar que una solución propuesta es elegante pero no se mantendrá bajo carga o no encajará en la arquitectura existente se convierte en una habilidad clave. +- **El nivel de entrada ha subido.** Siempre se esperaba que un desarrollador junior pudiera escribir código. Ahora se espera cada vez más que también puedan evaluar el código de otra persona, incluido el código escrito por una máquina. + +La conclusión práctica: invierte en los fundamentos (el modelo de memoria, el tiempo de vida de los objetos, la concurrencia, la arquitectura, la depuración). Todo lo que te permita juzgar si una solución es correcta. De eso se trata exactamente el [roadmap](README.md). + +## :hourglass: Una trampa para los que aún están aprendiendo + +El riesgo más grave de la IA para un desarrollador principiante no es "te quitará tu trabajo", sino que se interpondrá **en el camino del aprendizaje**. + +La habilidad surge de luchar con un problema: lo intentas, fallas, descubres por qué y un modelo mental de lo que está sucediendo permanece en tu cabeza. Si le preguntas a un asistente en cada dificultad, el problema se resuelve pero el modelo mental no. Después de un año de práctica como esa, resulta que no tienes forma de comprobar la respuesta del asistente. + +Qué hacer al respecto: + +- En los ejercicios de aprendizaje, **resuélvelo tú mismo primero**, y acude al asistente para una revisión de una solución terminada: "qué se podría haber hecho mejor aquí y por qué". +- Pide una explicación, no código: por qué de esta manera, cuáles son las alternativas, qué se rompe cuando cambian las condiciones. +- No pegues código que no puedas explicar línea por línea. Esta regla funciona igual de bien para el código de Stack Overflow y para el código de un modelo. +- De vez en cuando, escribe algo sin asistente en absoluto, para que puedas ver honestamente tu nivel real. + +## :handshake: Cómo usarlo de manera útil + +- **Como acelerador de rutina:** código repetitivo (boilerplate), estructura de pruebas, exploración de una API desconocida, borradores de documentación. +- **Como compañero de explicaciones:** "¿por qué el compilador se queja así?" — los modelos decodifican los errores de las plantillas (templates) de C++ notablemente mejor que el compilador. +- **Como navegador a través de una base de código desconocida:** comprender rápidamente dónde están las cosas y cómo se conectan. +- **Como revisor:** pídele que encuentre problemas en tu código. No como la última palabra, sino como un par de ojos más. + +Y tres reglas que vale la pena tener en cuenta en todo momento: verifica lo que se genera, sigue la política de tu empresa sobre el envío de código a servicios externos y recuerda los riesgos de las licencias. Más sobre esto en la sección de [herramientas de IA](Tooling.md). + +## :telescope: Lo que nadie sabe + +Sinceramente: nadie sabe cómo será la profesión en diez años, ni los autores de este roadmap, ni los propios autores de los modelos. Cualquiera que prediga con confianza que "todos serán reemplazados" o "nada cambiará" está haciendo pasar una ilusión por un hecho. + +Lo que se puede decir con confianza: la demanda de personas que entiendan cómo funcionan los sistemas y puedan ser responsables del resultado no ha desaparecido hasta ahora. Las herramientas de desarrollo siempre han cambiado: ensamblador, compiladores, IDEs, autocompletado, búsqueda en internet. Cada vez el estribillo era "ahora cualquiera puede programar", y cada vez había más trabajo, no menos, porque el desarrollo más barato abría nuevos problemas por resolver. El giro actual aún puede resultar diferente, pero hasta ahora no hay base para apostar que el conocimiento profundo perderá su valor repentinamente. + +--- + +[**A la página principal**](README.md) diff --git a/Spanish/AreasOfApplication.md b/Spanish/AreasOfApplication.md new file mode 100644 index 0000000..26026ed --- /dev/null +++ b/Spanish/AreasOfApplication.md @@ -0,0 +1,12 @@ +# :clipboard: Áreas de aplicación de C++ + +El lenguaje C++ tiene una amplia gama de aplicaciones, usándose principalmente cuando se requiere alto rendimiento o bajo consumo de memoria. Para aprender más sobre las áreas de aplicación específicas de C++, puedes encontrar recursos adicionales a continuación: +- [What Is C++ Used For? Top 12 Real-World Applications And Uses Of C++](https://www.softwaretestinghelp.com/cpp-applications/) +- [Why and where should you still use C/C++ languages?](https://hackernoon.com/why-and-where-should-you-still-use-cc-languages-6l1r838gh) +- [What Can You Do With C++?](https://www.ko2.co.uk/what-can-you-do-with-c-plus-plus/) +- [C++ Applications](https://www.stroustrup.com/applications.html) +- [What is C++ used for?](https://www.codecademy.com/resources/blog/what-is-c-plus-plus-used-for/) + +--- + +[**A la página principal**](../README.md) diff --git a/Spanish/Books/Junior.md b/Spanish/Books/Junior.md new file mode 100644 index 0000000..82226e9 --- /dev/null +++ b/Spanish/Books/Junior.md @@ -0,0 +1,51 @@ +# :yum: Junior + +## :innocent: Motivación y experiencia + +- [Robert Martin - The clean coder](https://www.amazon.com/Clean-Coder-Conduct-Professional-Programmers/dp/0137081073) + + El Tío Bob (Uncle Bob) comparte sus recomendaciones sobre cómo "sobrevivir" y tener éxito en la industria de TI. Este libro no se trata solo de habilidades técnicas. También presenta desafíos psicológicos y las luchas con ellos. + +- [Robert Martin - Clean Code: A Handbook of Agile Software Craftsmanship](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) + + A pesar de las críticas que pueda encontrar sobre este libro, seguimos creyendo que puede ser un recurso valioso para los nuevos desarrolladores a corto plazo. El libro presenta una colección de técnicas efectivas que pueden ayudarle a escribir código bien estructurado, legible y mantenible. Sin embargo, es importante no ver este libro como un evangelio y evitar convertirlo en un "culto de cargo" (cargo-cult). En su lugar, utilice este conocimiento de forma inteligente y seleccione las técnicas que mejor se adapten a sus necesidades y mejoren su estilo de codificación. + +- [Steve McConnell - Code Complete: A Practical Handbook of Software Construction](https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670) + + A pesar de su edad, este libro aún puede considerarse una "biblia" para los desarrolladores, ya que proporciona una descripción general completa de la industria de TI. Ofrece una gran cantidad de consejos prácticos sobre cómo crecer y desarrollarse como un profesional de primer nivel. + + +## :bar_chart: Informática (Computer Science) + +- [Thomas H. Cormen - Introduction to Algorithms](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844) + + Este libro sirve como un excelente seguimiento a "Grokking Algorithms". Profundiza en los algoritmos de clasificación comunes y el trabajo con listas, proporcionando información más detallada. El estilo de escritura es accesible y amigable. Leer este libro será útil para prepararse para una inmersión profunda en el campo de los algoritmos. + +## :pencil: C++ + +- [Scott Meyers - Effective C++: 55 Specific Ways to Improve Your Programs and Designs](https://www.amazon.com/Effective-Specific-Improve-Programs-Designs/dp/0321334876) + + Este libro es el recetario definitivo para los fundamentos de C++. Aunque cubre las características de C++03, la información que proporciona sigue siendo valiosa y relevante. Las recomendaciones descritas en el libro son perfectamente adecuadas para los últimos estándares. + +- [Jason Turner - C++ Best Practices: 45ish Simple Rules with Specific Action Items for Better C++](https://www.amazon.com/Best-Practices-Simple-Specific-Action/dp/B08SJSZKJ5) + + Esta es una recopilación de consejos para desarrolladores de C++ sin experiencia, centrándose en los errores más comunes. Las explicaciones son breves y van al grano. La mayoría de los consejos incluyen enlaces a recursos adicionales. Dado que el libro no ofrece un examen exhaustivo de cada consejo, se recomienda profundizar en cada uno de ellos en el futuro para comprender realmente el razonamiento detrás de los mismos. + +- [Herb Sutter, Andrei Alexandrescu - C++ Coding Standards: 101 Rules, Guidelines, and Best Practices](https://www.amazon.com/Coding-Standards-Rules-Guidelines-Practices/dp/0321113586) + + Este pequeño libro describe las mejores prácticas comunes para escribir código en proyectos comerciales. Es una compilación de experiencias recopiladas de varias empresas. Este libro también fue una base para los [C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines). Se recomienda comenzar con este libro primero antes de visitar las C++ Core Guidelines. Le dará una primera impresión de las pautas de código utilizadas en los proyectos. Después de leer el libro, puede visitar el sitio web de las C++ Core Guidelines para conocer los enfoques aprobados más recientes. + + +## :electric_plug: Habilidades duras (Hard skills) + +- [Eric Freeman, Elisabeth Robson - Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124) + + Este libro es un comienzo perfecto para estudiar patrones de diseño. Como otra alternativa, también puede visitar [refactoring.guru](https://refactoring.guru/design-patterns), pero en caso de utilizar este libro, podrá tener mucha práctica sobre la marcha que le ayudará a comprender mejor las ideas de los patrones de diseño comunes. + +- [Sanjay Madhav, Josh Glazer - Multiplayer Game Programming: Architecting Networked Games](https://www.amazon.com/Multiplayer-Game-Programming-Architecting-Networked/dp/0134034309) + + Este libro es una excelente introducción a la teoría de redes, explicando los fundamentos de las redes a través de ejemplos de videojuegos. Le ayudará a escribir su primera aplicación que funcione a través de una red y ganará experiencia práctica trabajando con redes en C++. Todos los ejemplos del libro están escritos usando C++11/14. + +--- + +[**Volver**](Overview.md) | [**Ir a la página principal**](../README.md) diff --git a/Spanish/Books/Middle.md b/Spanish/Books/Middle.md new file mode 100644 index 0000000..fe323e1 --- /dev/null +++ b/Spanish/Books/Middle.md @@ -0,0 +1,103 @@ +# :sunglasses: Middle + +## :pencil: C++ + +- [Scott Meyers - Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14](https://www.amazon.com/Effective-Modern-Specific-Ways-Improve/dp/1491903996) + + Es un nuevo capítulo en la colección de libros de Scott Meyers. Este libro recopila un conjunto de consejos para los estándares C++11/14. + +- Nicolai Josuttis: + - [C++17 - The Complete Guide](https://leanpub.com/cpp17) + - [C++20 - The Complete Guide](https://leanpub.com/cpp20) + + El libro de Meyers se detiene en C++14, y estos dos volúmenes continúan donde él lo dejó. Cada uno repasa sistemáticamente todo lo que añadió su estándar (tanto características del lenguaje como de la biblioteca) con ejemplos prácticos y consejos sobre cuándo (y cuándo no) usar las nuevas herramientas. + +- [Nicolai Josuttis - C++ Move Semantics: The Complete Guide](https://leanpub.com/cppmove) + + La semántica de movimiento (move semantics) es uno de esos temas que "parecen claros" hasta que comienzas a profundizar en los detalles: cuándo el compilador aplica un movimiento por su cuenta, en qué se diferencia `std::move` de `std::forward`, por qué a veces un movimiento se convierte silenciosamente en una copia, y cómo se relaciona la regla de los cinco (rule of five) con `noexcept`. El libro analiza todo esto paso a paso y con ejemplos. Es uno de los temas más frecuentes en las entrevistas de nivel Middle. + +- [Klaus Iglberger - C++ Software Design: Design Principles and Patterns for High-Quality Software](https://www.amazon.com/Software-Design-Principles-Patterns-High-Quality/dp/1098113160) + + Una versión moderna de los patrones de diseño, escrita específicamente para C++. Muestra cómo se ven los patrones clásicos cuando se construyen sobre los modismos (idioms) actuales (semántica de valor, borrado de tipos, `std::variant`) en lugar de profundas jerarquías de herencia, y es un gran puente entre conocer el lenguaje y diseñar con él. + +- [Anthony Williams - C++ Concurrency in Action](https://www.amazon.com/C-Concurrency-Action-Anthony-Williams/dp/1617294691/ref=sr_1_3?keywords=C%2B%2B+Concurrency+in+Action%3A+Practical+Multithreading&qid=1636314477&s=books&sr=1-3) + + Este libro es una guía completa sobre la programación multihilo y el uso de las características de la biblioteca estándar. Proporciona explicaciones detalladas sobre todas las primitivas y sus complejidades "detrás de escena". + +- Herb Sutter: + - [Exceptional C++: 47 Engineering Puzzles, Programming Problems, and Solutions](https://www.amazon.com/Exceptional-Engineering-Programming-Problems-Solutions/dp/0201615622) + - [Exceptional C++ Style: 40 New Engineering Puzzles, Programming Problems, and Solutions](https://www.amazon.com/Exceptional-Style-Engineering-Programming-Solutions/dp/0201760428) + - [More Exceptional C++: 40 New Engineering Puzzles, Programming Problems, and Solutions](https://www.amazon.com/More-Exceptional-Engineering-Programming-Solutions/dp/020170434X) + + La colección de libros cubre muchas tareas relacionadas con el diseño o la escritura de código en C++, ofreciendo una variedad de soluciones efectivas. Muchas de estas soluciones se han considerado modismos clásicos y se utilizan ampliamente en diversos proyectos. + +- [David Vandevoorde - C++ Templates: The Complete Guide](https://www.amazon.com/C-Templates-Complete-Guide-2nd/dp/0321714121) + + El libro más nuevo y relevante sobre la metaprogramación en C++, específicamente sobre plantillas (templates), es un trabajo completo que describe las técnicas y fundamentos relevantes añadidos en los estándares recientes, incluido C++17. Si busca escribir código genérico y parametrizado, este libro se convertirá en un recurso indispensable para usted, ofreciendo conocimientos sobre los conceptos básicos de las plantillas así como sobre una multitud de matices relacionados con diferentes técnicas. + + +## :bicyclist: Optimización para aplicaciones C++ + +- [Kurt Guntheroth - Optimized C++: Proven Techniques for Heightened Performance](https://www.amazon.com/Optimized-Proven-Techniques-Heightened-Performance/dp/1491922060) + + Este libro es una guía para mejorar el rendimiento de las aplicaciones en C++. Algunos de los consejos de este libro se basan en varios modismos y trucos descritos en los libros de Herb Sutter o Scott Meyers. Se recomienda leer este libro después de leer los libros mencionados anteriormente. + +- [Agner Fog - Optimizing software in C++](https://agner.org/optimize/optimizing_cpp.pdf) o [Optimization manuals](https://agner.org/optimize) + + Las guías de orientación práctica proporcionan información completa sobre las posibilidades de optimización potenciales para aplicaciones desarrolladas en C++ o relacionadas con la interacción con la CPU, la memoria, etc. + +## :electric_plug: Habilidades duras (Hard skills) + +- [Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides or "Gang of Four" - Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612) + + Este libro es una guía clásica sobre patrones de diseño. Cada patrón se describe detalladamente y se aconseja sobre su caso de uso apropiado. Este libro es una buena continuación de "Head First Design Patterns" de Eric Freeman. Sin embargo, esté preparado, ya que este libro es más complejo que el anterior. + +- [Gary McLean Hall - Adaptive Code](https://www.amazon.com/Adaptive-Code-Developer-Best-Practices/dp/0136891446) + + Este libro es un excelente recurso para comprender los principios SOLID del diseño de software. Las explicaciones se presentan de forma sencilla, haciéndolas fáciles de entender. Los ejemplos de código, que están escritos en C#, también son sencillos y sirven para ilustrar los principios con eficacia. + +- [Robert Martin - Clean Architecture: A Craftsman's Guide to Software Structure and Design](https://www.amazon.com/Clean-Architecture-Craftsmans-Software-Structure/dp/0134494164) + + Este libro, escrito por el Tío Bob (Uncle Bob), proporciona orientación sobre cómo abordar el diseño de software con un enfoque en la arquitectura. Enfatiza la importancia de pensar en la arquitectura de una aplicación o componente antes de comenzar a codificar. El libro ofrece conocimientos sobre qué considerar al analizar el diseño de una solución y ayuda a prevenir errores comunes en el diseño de software. Este libro es un gran punto de partida para las personas interesadas en tareas arquitectónicas en el diseño de software que buscan obtener una comprensión más profunda del campo. El conocimiento contenido en este libro es ampliamente utilizado entre ingenieros y les ayudará a evitar errores generalizados. + +- [Samary Baranov - Finite State Machines and Algorithmic State Machines: Fast and Simple Design of Complex Finite State Machines](https://www.amazon.com/Finite-State-Machines-Algorithmic-Complex-ebook/dp/B078RYYBCJ) + + Esta es una guía breve y práctica sobre cómo abordar la programación utilizando la teoría de máquinas de estado finito. No encontrará una explicación más simple y elegante de la teoría de máquinas finitas y sus aplicaciones prácticas. + +- [Vladimir Khorikov - Unit Testing Principles, Practices, and Patterns: Effective testing styles, patterns, and reliable automation for unit testing, mocking, and integration testing with examples in C#](https://www.amazon.com/Unit-Testing-Principles-Practices-Patterns-ebook/dp/B09782L692) + + El libro proporciona información sobre las mejores prácticas y los antipatrones comunes que rodean el tema de las pruebas unitarias (unit testing). Después de leer este libro, armado con sus nuevas habilidades, tendrá el conocimiento necesario para convertirse en un experto en la entrega de proyectos exitosos que son fáciles de mantener y extender, gracias a las pruebas que construya en el camino. + + +## :zap: Sistemas operativos + +- [Andrew S. Tanenbaum - Modern Operating Systems](https://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X) + + Esta es una guía completa de los sistemas operativos, que cubre su construcción y diversos aspectos como los sistemas de archivos, redes, gestión de memoria, programación de tareas y multihilo. El libro proporciona explicaciones detalladas en términos simples, sin centrarse en una distribución de SO específica. Cada capítulo ofrece una exploración detallada de diferentes aspectos de los sistemas operativos, convirtiéndolo en un recurso fundamental para comprender este tema complejo. + +- [Mark Russinovich - Windows Internals, Part 1](https://www.amazon.com/Windows-Internals-Part-architecture-management/dp/0735684189), [Mark Russinovich - Windows Internals, Part 2](https://www.amazon.com/Windows-Internals-Part-2-7th/dp/0135462401) + + Este libro profundiza en los mismos temas que el libro anterior, pero centrándose exclusivamente en el sistema operativo Microsoft Windows. Proporciona una mirada profunda y detallada a cada aspecto del SO con un enfoque específico en Windows y cubre varios matices y aspectos que pueden no ser declarados oficialmente por los desarrolladores. Es un recurso útil para aquellos que desarrollan aplicaciones de bajo nivel que requieren una interacción intensiva con las bibliotecas del sistema del SO. + +- [Christopher Negus - Linux Bible](https://www.amazon.com/Linux-Bible-Christopher-Negus/dp/1394317468) + + Este libro puede servir como continuación del trabajo de Tanenbaum, profundizando en las complejidades del sistema operativo Linux. El libro incluye un análisis detallado de varios aspectos del SO, centrándose en distribuciones populares como Red Hat, Ubuntu y Fedora. Es un recurso ideal para los desarrolladores que utilizan Linux a diario. + +- [Ulrich Drepper - What Every Programmer Should Know About Memory](https://people.freebsd.org/~lstewart/articles/cpumemory.pdf) + + Este artículo proporciona una descripción general completa de cómo funciona la memoria de la PC y por qué opera de la manera descrita. Presenta no solo información de alto nivel, sino que también profundiza en aspectos de bajo nivel, lo que lo hace ideal para aquellos que desean profundizar en el tema. + + +## :globe_with_meridians: Redes de computadoras + +- [Andrew S. Tanenbaum - Computer Networks](https://www.amazon.com/Computer-Networks-Andrew-Tanenbaum/dp/0136764053) + + Un libro clásico sobre los fundamentos teóricos de las redes de computadoras que proporciona una descripción detallada, comenzando desde la capa física hasta los protocolos de transferencia de datos. Será extremadamente útil para los desarrolladores que están muy involucrados en proyectos que interactúan con redes. + +- [Victor Olifer - Computer Networks: Principles, Technologies and Protocols for Network Design](https://www.amazon.com/Computer-Networks-Principles-Technologies-Protocols-ebook/dp/B001GQ35P4) + + Este libro proporciona información completa sobre los conceptos básicos de las redes informáticas. Puede presentar la información de una manera un poco más compleja en comparación con el trabajo de Tanenbaum. Como resultado, se recomienda elegir el libro que presente la información en un estilo que sea más adecuado para usted. + +--- + +[**Volver**](Overview.md) | [**Ir a la página principal**](../README.md) diff --git a/Spanish/Books/Overview.md b/Spanish/Books/Overview.md new file mode 100644 index 0000000..bc646f2 --- /dev/null +++ b/Spanish/Books/Overview.md @@ -0,0 +1,12 @@ +# :books: Libros y fuentes + +Esta guía presenta una colección de libros para aprender C++, divididos en niveles de dificultad apropiados. Se sugiere determinar su competencia actual y seleccionar los libros que se ajusten a ella. El enfoque de esta guía es proporcionar una comprensión general de C++ y el desarrollo de software, en lugar de cubrir temas especializados. Si busca información más específica, se recomienda contactar a expertos en su área de interés. + +- :blue_book: [PreJunior](PreJunior.md) +- :green_book: [Junior](Junior.md) +- :orange_book: [Middle](Middle.md) +- :closed_book: [Senior](Senior.md) + +--- + +[**Ir a la página principal**](../README.md) diff --git a/Spanish/Books/PreJunior.md b/Spanish/Books/PreJunior.md new file mode 100644 index 0000000..7efe8c6 --- /dev/null +++ b/Spanish/Books/PreJunior.md @@ -0,0 +1,48 @@ +# :alien: Pre-Junior + +## :innocent: Motivación y experiencia + +- [Chad Fowler - Passionate Programmer](https://www.amazon.com/Passionate-Programmer-Remarkable-Development-Pragmatic-ebook/dp/B00AYQNR5U) + + El libro es un clásico en el género de la motivación para principiantes. Chad Fowler comparte su experiencia sobre cómo convertirse en un programador profesional y navegar en la industria de TI. + + +## :bar_chart: Informática (Computer Science) + +- [Wladston Ferreira Filho - Computer Science Distilled: Learn the Art of Solving Computational Problems](https://www.amazon.com/Computer-Science-Distilled-Computational-Problems/dp/0997316020) + + El libro proporciona una descripción general completa de varios conceptos básicos en informática, incluyendo matemáticas, algoritmos, bases de datos y los fundamentos de hardware de las computadoras. Sirve como un punto de partida ideal para descubrir y priorizar áreas de interés en el campo. + +- [Charles Petzold - Code: The Hidden Language of Computer Hardware and Software](https://www.amazon.com/Code-Language-Computer-Hardware-Software/dp/0735611319) + + Antes de comenzar su estudio de C++, se recomienda leer este libro primero. Proporciona una explicación sencilla de cómo funciona una computadora, evitando aspectos técnicos o teóricos complejos. Los conceptos presentados en este libro son fundamentales y seguirán siendo relevantes en el futuro. También le ayudará en su comprensión de las ideas fundamentales de C++ más adelante. Este libro sirve como un complemento al anterior ya que profundiza en el funcionamiento de las computadoras. + +- [Aditya Bhargava - Grokking Algorithms: An Illustrated Guide for Programmers and Other Curious People](https://www.amazon.com/Grokking-Algorithms-illustrated-programmers-curious/dp/1617292230) + + El libro proporciona una brillante introducción al mundo de los algoritmos y estructuras de datos de la informática para principiantes. También incluye una lista de tareas que le ayudarán a implementar sus primeros algoritmos. + + +## :pencil: C++ + +- [Stephen Prata - C++ Primer Plus](https://www.amazon.com/Primer-Plus-6th-Developers-Library/dp/0321776402) + + El libro es un excelente punto de partida para personas que recién comienzan su viaje en el mundo de C++. No se requiere conocimiento previo para comenzar. El libro también incluye una lista de ejercicios que pueden ayudarle a obtener experiencia práctica y una comprensión más profunda de los conceptos básicos de C++. + +- [Stanley Lippman - C++ Primer](https://www.amazon.com/Primer-5th-Stanley-B-Lippman/dp/0321714113) + + Este libro es un gran complemento al anterior. Se recomienda usarlo en paralelo con el libro de Prata. Se aconseja encontrar un equilibrio entre estos libros, ya que la información se presenta de manera diferente. Mezclar información de ambos libros ayudará a comprender mejor varios temas y aspectos del lenguaje. + +- [Andrew Koenig - Accelerated C++: Practical Programming by Example](https://www.amazon.com/Accelerated-C-Practical-Programming-Example/dp/020170353X) + + Este libro es una excelente opción para principiantes. Cada capítulo proporciona una descripción completa de diferentes aspectos fundamentales del lenguaje. Al completar cada capítulo, se ofrece al lector una serie de ejercicios para practicar y reforzar su comprensión. El libro cubre los temas más fundamentales que se pueden aplicar en futuros estudios de nuevos mecanismos del lenguaje. Se recomienda leer este libro después de estudiar los libros de Prata o Lippman o junto a ellos. + + +## :electric_plug: Habilidades duras (Hard skills) + +- [MSDN](https://docs.microsoft.com/en-us/cpp/build/vscpp-step-0-installation?view=msvc-160) + + Si recién comienza su viaje de aprendizaje, se recomienda comenzar a practicar y hacer ejercicios en el IDE Microsoft Visual Studio (Community Edition). Actualmente es uno de los IDE más amigables para principiantes, tanto en términos de instalación como de uso, ¡y es completamente gratis! Esto le permitirá concentrarse en el lenguaje y no agobiarse por el entorno de desarrollo. Una útil guía en MSDN explica los pasos para instalar Visual Studio, crear su primer proyecto de consola e implementar su primera aplicación. + +--- + +[**Volver**](Overview.md) | [**Ir a la página principal**](../README.md) diff --git a/Spanish/Books/Senior.md b/Spanish/Books/Senior.md new file mode 100644 index 0000000..db786cd --- /dev/null +++ b/Spanish/Books/Senior.md @@ -0,0 +1,61 @@ +# :smiling_imp: Senior + +## :pencil: C++ + +- Hay pocas recomendaciones de libros a nivel sénior: se asume que tienes un sólido dominio del lenguaje, y el principal desafío es mantenerse actualizado con nuevos estándares, funciones y herramientas. Canales útiles para ello: + - [Standard C++ Foundation news and WG21 trip reports](https://isocpp.org/) - resúmenes de lo que el comité de estandarización está trabajando, escritos para profesionales. + - Charlas en conferencias - consulta los [canales de YouTube de conferencias](../CommunitySources.md) (CppCon, Meeting C++, C++Now); las presentaciones principales y las charlas sobre "Qué hay de nuevo en C++XX" son una forma eficiente de mantenerse al día. + +- [John Lakos - Large-Scale C++ Volume I: Process and Architecture](https://www.informit.com/store/large-scale-c-plus-plus-process-and-architecture-volume-9780201717068) + + Un tratamiento profundo del diseño físico: cómo organizar componentes, paquetes y dependencias para que una base de código de C++ siga siendo mantenible a medida que crece a millones de líneas. Muy relevante para desarrolladores sénior que se encargan de la estructura de grandes proyectos de larga duración. + + +## :muscle: Gestión de equipos + +- [J. Hank Rainwater - Herding Cats: A Primer for Programmers Who Lead Programmers ](https://www.amazon.com/Herding-Cats-Primer-Programmers-Lead/dp/1590590171) + + Este libro clásico arroja luz sobre los desafíos que surgen al gestionar desarrolladores. Aunque algunos aspectos del libro pueden estar desactualizados, todavía sirve como un gran punto de partida para aprender sobre la gestión de programadores. Muchos de sus capítulos siguen siendo relevantes y proporcionan una comprensión inicial de la gestión de personas, lo cual puede ser útil al supervisar a desarrolladores júnior. + +- [Michael Lopp - Managing Humans: Biting and Humorous Tales of a Software Engineering Manager](https://www.amazon.com/Managing-Humans-Humorous-Software-Engineering/dp/1484221575) + + Este libro explica las responsabilidades y los desafíos que enfrentan los líderes. Le ayudará a desarrollar las habilidades para pensar como un gerente y comprender los problemas que enfrentan aquellos en puestos de gestión. Este conocimiento puede ayudar a mejorar la comunicación y la colaboración entre usted, su gerente y el equipo de desarrollo. + +- [Frederick Brooks - Mythical Man-Month, The: Essays on Software Engineering](https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959) + + Este libro se considera un clásico en la gestión de proyectos y se centra en los errores que llevan a que los proyectos fracasen. Aunque está parcialmente desactualizado, es un gran punto de partida para los nuevos gerentes a fin de protegerse de los errores típicos. + +- [Tom DeMarco - The Deadline: A Novel About Project Management](https://www.amazon.com/Deadline-Novel-About-Project-Management-ebook/dp/B006MN4RAS) + + El libro es una novela que cuenta la historia de un gerente y su trabajo en la gestión de proyectos. Es increíblemente útil porque transmite las experiencias diarias de un gerente de forma artística. Proporciona una mirada integral a los diversos desafíos que un gerente enfrenta a diario. + +- [Daniel Kahneman - Thinking, Fast and Slow](https://www.amazon.com/Thinking-Fast-Slow-Daniel-Kahneman/dp/0374533555) + + El libro clásico sobre las falacias lógicas en el pensamiento humano es una lectura obligada. Es útil para ayudarle a adoptar un enfoque más racional en la toma de decisiones, al considerar los sesgos cognitivos y las distorsiones en el pensamiento humano. Esta es una habilidad esencial para los especialistas involucrados en la toma de decisiones críticas. Si el libro parece aburrido, puede intentar buscar obras alternativas que discutan los sesgos cognitivos. + + +## :clipboard: Requisitos y arquitectura de software + +- [Karl Wiegers - Software Requirements](https://www.amazon.com/Software-Requirements-Developer-Best-Practices/dp/0735679665) + + Este libro es un recurso excelente para cualquiera que participe en el proceso de recopilación y refinamiento de requisitos de software. Proporciona orientación sobre cómo comunicarse eficazmente con gerentes, clientes y desarrolladores para recopilar requisitos y convertir ideas abstractas en soluciones concretas y técnicas con limitaciones bien definidas. Ya sea que sea nuevo en los requisitos de software o un profesional experimentado, este libro será un recurso valioso. + +- [Len Bass, Paul Clements, Rick Kazman - Software Architecture in Practice](https://www.amazon.com/Software-Architecture-Practice-SEI-Engineering/dp/0136886094) + + Un trabajo clásico sobre los fundamentos de los enfoques arquitectónicos en el diseño de software, que contiene una colección de patrones arquitectónicos clásicos y técnicas para construir grandes sistemas de software. + +- [Mark Richards, Neal Ford - Fundamentals of Software Architecture: An Engineering Approach](https://www.amazon.com/Fundamentals-Software-Architecture-Comprehensive-Characteristics/dp/1492043451) + + Este libro ofrece una visión general de los conceptos fundamentales del diseño de software centrados en los principios de la ingeniería. Cubre temas como la fiabilidad, la repetibilidad y la previsibilidad de los componentes del sistema, y ofrece un enfoque para el diseño de software desde una perspectiva de ingeniería. + +- [Martin Fowler - Patterns of Enterprise Application Architecture](https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420) + + El libro proporciona una descripción completa de diferentes enfoques arquitectónicos para la construcción de sistemas corporativos. Abarca una amplia gama de aplicaciones, desde transacciones financieras hasta la gestión de documentos, y está diseñado para ser relevante para sistemas de diferentes grados de complejidad y enfoque. Ya sea que sea un ingeniero de software experimentado o recién comience en el campo, este libro puede ser un recurso invaluable para construir sistemas corporativos robustos y escalables. + +- [Chris Richardson - Microservices Patterns](https://www.amazon.com/Microservices-Patterns-examples-Chris-Richardson/dp/1617294543) + + Este libro será de utilidad para quienes quieran aprender sobre la arquitectura de microservicios, así como para desarrolladores y arquitectos que buscan formas de construir sistemas escalables y mantenibles. El libro proporciona información práctica y ejemplos del mundo real para ayudar a los lectores a comprender cómo diseñar, construir e implementar sistemas basados en microservicios. Ya sea que esté comenzando a aprender sobre este enfoque arquitectónico o que busque profundizar su conocimiento existente, este libro puede proporcionar una valiosa orientación y las mejores prácticas para ayudarlo a tener éxito en sus proyectos. + +--- + +[**Volver**](Overview.md) | [**Ir a la página principal**](../README.md) diff --git a/Spanish/CommunitySources.md b/Spanish/CommunitySources.md new file mode 100644 index 0000000..cace5e6 --- /dev/null +++ b/Spanish/CommunitySources.md @@ -0,0 +1,41 @@ +# :gem: Fuentes de la comunidad + +## :bookmark_tabs: C++ en General + +- [CppReference](https://en.cppreference.com) +- [C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines) +- [Microsoft GSL C++ (Guidelines Support Library)](https://github.com/microsoft/GSL) +- [Noticias del Comité de Estandarización de C++](https://isocpp.org/) +- [C++ Online Compiler Explorer](https://gcc.godbolt.org) +- [C++ Insights](https://cppinsights.io/) - Ve tu código con los ojos del compilador: muestra cómo el compilador transforma plantillas (templates), lambdas, bucles basados en rangos (range-based loops), etc. +- [r/cpp](https://www.reddit.com/r/cpp/) - La comunidad de C++ en Reddit: noticias, artículos y discusiones. + +## :satellite: Conferencias populares de C++ + +- [Cpp Con](https://cppcon.org/) +- [Meeting C++](https://meetingcpp.com/) +- [C++ Now](https://cppnow.org/) + +## :tv: Canales de YouTube de conferencias de C++ + +- [Cpp Con](https://www.youtube.com/user/CppCon) +- [Meeting C++](https://www.youtube.com/user/MeetingCPP) +- [C++ Now](https://www.youtube.com/user/BoostCon) + +## :exclamation: Fuentes alternativas para aprender C++ + +- [Learncpp.com](https://www.learncpp.com/) - Es un sitio web gratuito dedicado a enseñarte cómo programar en C++. Se actualiza regularmente. +- [Hackingcpp.com](https://hackingcpp.com/index.html) - El portal web todo en uno con diferentes colecciones de materiales relacionados con C++: libros, hojas de referencia (cheat sheets), grabaciones de conferencias, etc. +- [Awesomecpp.com](https://awesomecpp.com) - Una colección curada de recursos de C++. +- [Cpp Con (back to basics)](https://www.youtube.com/playlist?list=PLHTh1InhhwT5o3GwbFYy3sR7HDNRA353e) +- [C++ Weekly](https://www.youtube.com/@cppweekly) - El programa de YouTube de Jason Turner con episodios cortos semanales sobre características de C++ y mejores prácticas. +- [CppCast](https://cppcast.com/) - Un podcast para desarrolladores de C++ con entrevistas sobre el lenguaje, bibliotecas y la comunidad. + +## :star: Otros repositorios interesantes + +- [A cheatsheet of modern C++ language and library features](https://github.com/AnthonyCalandra/modern-cpp-features) +- [Collection of libraries and frameworks for C++](https://github.com/fffaraz/awesome-cpp) + +--- + +[**A la página principal**](README.md) diff --git a/Spanish/Compliance.md b/Spanish/Compliance.md new file mode 100644 index 0000000..34d252a --- /dev/null +++ b/Spanish/Compliance.md @@ -0,0 +1,77 @@ +# :balance_scale: Estándares de codificación y requisitos normativos + +C++ ha ocupado tradicionalmente las áreas donde el costo de un error no se mide en dinero perdido sino en vidas humanas: electrónica automotriz, dispositivos médicos, aviónica, automatización industrial, transporte ferroviario. En tales proyectos, la libertad del lenguaje se convierte en un problema, por lo que se restringe, con un conjunto de reglas de codificación, comprobaciones obligatorias y un proceso de desarrollo documentado. + +Este artículo es un mapa general del territorio, no una guía de certificación. Su objetivo es que comprendas a qué se refiere cuando una oferta de trabajo dice "experiencia en MISRA" o "proyectos ISO 26262", y que sepas dónde buscar los detalles. + +Hay una gran cantidad de estándares y requisitos, y a continuación solo se recopilan los más destacados. No existe un "conjunto obligatorio" único: cada proyecto utiliza su propio subconjunto según la industria, el país, el cliente y la clase de criticidad. Tiene sentido profundizar en un estándar específico cuando te lo encuentras realmente en tu proyecto, no solo por si acaso. + +> :warning: Los requisitos y los plazos cambian. Antes de tomar decisiones, verifica con las ediciones actuales de los estándares y con los abogados de tu empresa: este artículo es para orientación, no para conclusiones legales. + +## :straight_ruler: Estándares de codificación + +Restringen el lenguaje a un subconjunto con menos formas de dispararte en el pie: sin asignación dinámica de memoria después de la inicialización, sin excepciones, sin conversiones de tipos implícitas, etc. El cumplimiento es verificado por analizadores estáticos; tales conjuntos de reglas no se verifican a mano. + +* :arrow_forward: **MISRA C++:2023** - [misra.org.uk](https://misra.org.uk) + + El conjunto de reglas más conocido para C++ en sistemas críticos para la seguridad. Reemplazó a MISRA C++:2008 y cubre C++17. Un cambio importante: absorbió las pautas de **AUTOSAR C++14**, por lo que en lugar de dos conjuntos de reglas que compiten, como antes, ahora hay uno solo avanzando. Si te encuentras con un proyecto en AUTOSAR C++14, esa es la generación anterior del mismo enfoque ([autosar.org](https://www.autosar.org)). + +* :arrow_forward: **SEI CERT C++** - [wiki.sei.cmu.edu](https://wiki.sei.cmu.edu/confluence/pages/viewpage.action?pageId=88046682) + + Un conjunto de reglas con énfasis en la seguridad (security): cómo evitar construcciones que conducen a vulnerabilidades. A diferencia de MISRA, está disponible de forma gratuita y abierta: una buena manera de familiarizarse con el género en sí, incluso si tu proyecto no está siendo certificado. + +* :arrow_forward: **C++ Core Guidelines** - [isocpp.github.io](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines) + + Pautas de Bjarne Stroustrup y Herb Sutter. A diferencia de MISRA, no restringen el lenguaje, sino que te empujan hacia un estilo moderno. Formalmente no son un documento regulatorio, pero son útiles para cualquier desarrollador de C++; se pueden verificar parcialmente a través de `clang-tidy` y la [Microsoft GSL](https://github.com/microsoft/GSL). + +## :shield: Seguridad funcional + +Éstos responden a la pregunta "qué debe suceder para que el sistema no haga daño en caso de un fallo". Regulan no tanto el código como el proceso: requisitos, trazabilidad, pruebas, documentación y calificación de las herramientas utilizadas. + +El estándar base en esta área es **IEC 61508**, que introduce los Niveles de Integridad de Seguridad (Safety Integrity Levels) SIL 1-4. Los estándares de la industria a continuación son sus adaptaciones: + +* :arrow_forward: **ISO 26262** - automotriz - [iso.org](https://www.iso.org/standard/68383.html) + + Seguridad funcional de vehículos de carretera. Introduce los niveles ASIL de la A a la D, donde D es el más estricto (por ejemplo, control de frenos o dirección). Aquí es donde el emparejamiento "ISO 26262 + MISRA C++" se encuentra más a menudo. + +* :arrow_forward: **IEC 62304** - software médico - [iso.org](https://www.iso.org/standard/38421.html) + + El ciclo de vida del software para dispositivos médicos. Define las clases de seguridad A, B y C dependiendo de si un fallo puede provocar daños a la salud y qué tan grave. El cumplimiento de este estándar es la forma principal de demostrar la conformidad con el Reglamento Europeo de Dispositivos Médicos **MDR** ([Reglamento (UE) 2017/745](https://eur-lex.europa.eu/eli/reg/2017/745/oj)), así como con los requisitos de la FDA en los EE. UU. + +* :arrow_forward: **DO-178C** - aviónica - [rtca.org](https://www.rtca.org) + + Requisitos para software aerotransportado. Los niveles de criticidad DAL van de la A a la E; el nivel A requiere, entre otras cosas, cobertura de pruebas a nivel de condiciones individuales dentro de expresiones lógicas (MC/DC). Se considera uno de los estándares más exigentes y costosos de cumplir en la industria. + +## :lock: Ciberseguridad y la cadena de suministro + +Un tema relativamente nuevo para el mundo de C++: los reguladores están transfiriendo la responsabilidad de las vulnerabilidades al proveedor de software. + +* :arrow_forward: **Ley de Resiliencia Cibernética de la UE (CRA)** - [digital-strategy.ec.europa.eu](https://digital-strategy.ec.europa.eu/en/policies/cyber-resilience-act) + + Una regulación de la UE que cubre productos con elementos digitales suministrados al mercado europeo, desde controladores industriales hasta electrónica de consumo. Requiere un desarrollo seguro, el lanzamiento de actualizaciones de seguridad durante todo el período de soporte y la notificación de vulnerabilidades explotadas activamente. Entró en vigor en diciembre de 2024, y las obligaciones principales se aplicarán a partir de finales de 2027 y las obligaciones de notificación antes. Es importante destacar que afecta no solo a las industrias "críticas para la seguridad", sino a prácticamente cualquier software que forme parte de un producto que se vende. + +* :arrow_forward: **SBOM (Software Bill of Materials)** - [spdx.dev](https://spdx.dev), [cyclonedx.org](https://cyclonedx.org) + + Un inventario legible por máquina de todos los componentes y dependencias que se incluyen en el software entregado: la "lista de ingredientes", por analogía con una etiqueta en un paquete. Es necesario para que cuando se encuentre una vulnerabilidad en una biblioteca popular, puedas responder rápidamente a la pregunta "¿la tenemos?". Los dos formatos principales son SPDX y CycloneDX; ambos están estandarizados. Para C++ el tema es tangible: las dependencias a menudo se incorporan como código fuente o se compilan a mano, y sin un SBOM no siempre es obvio qué terminó exactamente en la compilación (build). + +## :computer: Qué significa esto en la práctica + +Si terminas en un proyecto de este tipo, lo que cambia no es tanto el lenguaje como el entorno alrededor del código: + +- **Un subconjunto del lenguaje.** Algunas funciones familiares estarán prohibidas, por lo general la memoria dinámica después de la inicialización, excepciones, RTTI y a veces plantillas (templates) y la biblioteca estándar en su conjunto. +- **Análisis estático obligatorio.** La compilación falla no solo por errores del compilador sino por violaciones de las reglas. Las desviaciones de las reglas se documentan y se acuerdan por escrito, no simplemente se suprimen en el código. +- **Trazabilidad.** Para cada línea de código puedes rastrear de qué requisito provino y qué prueba la cubre. De ahí las altas exigencias sobre cómo se redactan las tareas y los commits. +- **Calificación de herramientas.** El compilador, el analizador y el framework de pruebas también deben justificarse, por lo que las versiones se actualizan rara vez, y "solo agarrar el último GCC" no siempre es posible. +- **Revisión y documentación intensas.** El volumen de documentos adjuntos puede superar el volumen de código, y los plazos pueden exceder notablemente a los del desarrollo ordinario. + +## :question: Quién necesita esto realmente + +**No todos.** Si escribes juegos, aplicaciones de escritorio, backends o sistemas de trading, en la práctica lo más probable es que no te encuentres con estos estándares, y no tiene sentido estudiarlos especialmente. + +El tema se vuelve obligatorio si entras en la electrónica automotriz, dispositivos médicos, aviación, espacio, transporte ferroviario o automatización industrial. Para todos los demás es suficiente saber que estos estándares existen y de qué tratan, eso es suficiente para una entrevista. + +La excepción es **CRA y SBOM**. Se refieren a una gama mucho más amplia de productos que la seguridad funcional clásica, por lo que vale la pena familiarizarse con ellos incluso como un desarrollador "común" cuyos productos se venden en Europa. + +--- + +[**A la página principal**](README.md) diff --git a/Spanish/FunCpp.md b/Spanish/FunCpp.md new file mode 100644 index 0000000..eea94db --- /dev/null +++ b/Spanish/FunCpp.md @@ -0,0 +1,21 @@ +# :space_invader: C++ - No es ciencia espacial + +El C++ moderno es mucho más simple de lo que comúnmente se percibe. El lenguaje ha sufrido cambios significativos a lo largo de los años y ha adquirido la capacidad de escribir código seguro y eficiente. Con los estándares más recientes, no hay necesidad de preocuparse por las fugas de memoria. El compilador también se ha vuelto mucho más inteligente, realizando una gran cantidad de optimizaciones en tu código para ofrecer el máximo rendimiento. Sin embargo, todavía es posible optimizar el código mediante ajustes y trucos manuales. + +La principal deficiencia del lenguaje es la falta de un gestor de paquetes estándar (package manager). Aunque varios productos apuntan a llenar este vacío, ninguno ha tenido éxito hasta ahora. + +Además, C++ ha sufrido por su propio paradigma de "El desarrollador no paga por lo que no usa". En la práctica, los desarrolladores de software comercial no prestan mucha atención a las dependencias, lo que resulta en la situación opuesta donde el desarrollador tiene que pagar cada vez que necesita una dependencia. Esto lleva a efectos secundarios "interesantes" durante la construcción (build) del proyecto. Sin embargo, este problema también se está resolviendo gradualmente. + +Para empezar con C++, uno necesita una comprensión básica de: +- Aritmética +- Álgebra booleana +- Dibujo de diagramas de flujo +- Representación de números en diferentes sistemas numéricos + +A pesar de su historia, el C++ moderno es mucho más simple de lo que solía ser. + +¡No tengas miedo de aprenderlo y buena suerte! :dizzy: + +--- + +[**A la página principal**](../README.md) diff --git a/Spanish/Grades/Junior.md b/Spanish/Grades/Junior.md new file mode 100644 index 0000000..b0f9fc5 --- /dev/null +++ b/Spanish/Grades/Junior.md @@ -0,0 +1,33 @@ +# :yum: Junior C++ + +## :question: ¿Quién es? + +Es un desarrollador júnior que tiene conocimientos teóricos del desarrollo de software y poca experiencia práctica de proyectos personales o educativos. También puede tener una comprensión teórica de cómo funciona la industria. Los desarrolladores júnior pueden realizar tareas simples dentro de un proyecto real bajo la guía de colegas experimentados. + +## :computer: ¿Qué habilidades de programación se esperan? + +- Capacidad para leer la documentación de bibliotecas, frameworks, etc. +- Capacidad para recopilar e integrar bibliotecas de terceros en el proyecto. +- Capacidad para leer y comprender código escrito por otros desarrolladores. +- Capacidad para buscar y corregir errores utilizando el depurador o los datos de registro (logs). +- Capacidad para escribir pruebas para el código. +- Conocimiento básico y experiencia práctica con Git. + +## :bust_in_silhouette: ¿Qué habilidades generales se esperan? + +- Capacidad de aprendizaje rápido. +- Capacidad para buscar información de forma independiente en Internet, libros, etc. +- Capacidad para hacer preguntas a los colegas de manera oportuna y apropiada. +- Capacidad para trabajar eficazmente en un entorno de equipo. + +## :eyes: Consejos y recomendaciones + +- Intenta encontrar un grupo de personas entusiastas en tu empresa y únete a ellos. Pueden ser una fuente de conocimiento y experiencia para ti. +- No dudes en hacer preguntas a colegas más experimentados. No hay preguntas estúpidas, solo malas respuestas. +- No te absorbas demasiado en una tarea durante demasiado tiempo. Si después de varios intentos, no puedes avanzar, comunícate con tus colegas para pedir ayuda de inmediato. Ellos esperan que la tarea se complete dentro de un marco de tiempo razonable. Tu objetivo principal es resolver problemas, no crearlos para el equipo. +- Cuando te enfrentes a dificultades, intenta proponer algunas posibles soluciones por tu cuenta antes de buscar la orientación de tu mentor. Tu mentor puede luego ajustar o mejorar tu solución. +- Los desarrolladores júnior a menudo caen en la trampa de pensar que escribir más líneas de código equivale a ser un mejor programador. No cometas este error. Cuanto más código escribas, mayor será la probabilidad de errores. Idealmente, tu código debería escribirse de tal manera que, cuando vuelvas a él seis meses después, puedas comprender rápidamente qué hace. Un buen desarrollador no es alguien que escribe mucho código, sino más bien se comporta como un samurái, entregando un golpe preciso y efectivo en lugar de balancear su espada sin rumbo. + +--- + +[**Volver**](Overview.md) | [**Ir a la página principal**](../README.md) diff --git a/Spanish/Grades/Middle.md b/Spanish/Grades/Middle.md new file mode 100644 index 0000000..617647d --- /dev/null +++ b/Spanish/Grades/Middle.md @@ -0,0 +1,50 @@ +# :sunglasses: Middle C++ + +## :question: ¿Quién es? + +Es un desarrollador que comprende el contexto técnico del desarrollo de software y tiene la capacidad de crear un diseño y una solución para una funcionalidad que es parte de una aplicación o componente. El diseño también se puede crear incluso cuando hay una cantidad insuficiente de requisitos. Esta persona tiene antecedentes en experiencia comercial y está familiarizada con los procesos de negocio comunes en el desarrollo. + +En general, el desarrollador de nivel medio (middle) resuelve tareas técnicas, y en comparación con un Junior, esta persona puede completar el trabajo sin ayuda o con una asistencia mínima de un ingeniero Sénior/Líder. + + +## :computer: ¿Qué habilidades de programación se esperan? + +- Ya no ve un compilador y un lenguaje de programación como una "caja mágica"; es capaz de resolver cualquier obstáculo o sorpresa generando hipótesis, validándolas y confirmándolas o rechazándolas. +- Tiene una comprensión profunda de los conceptos fundamentales de C++ y conocimiento de otros lenguajes de programación, siendo capaz de compararlos. +- Escribe código legible, extensible y mantenible. +- Familiarizado con patrones y principios de diseño y capaz de tomar decisiones técnicas. +- Tiene una clara comprensión del contexto técnico de C++, que incluye: + - el proceso de escritura de código (como usar IDE, editores de texto y seguir las mejores prácticas) + - almacenamiento del código fuente y del producto (como usar sistemas de control de versiones y administradores de paquetes) + - compilación (compiladores, sistemas de construcción y bibliotecas) + - pruebas (frameworks de pruebas y estrategias) + - envío/despliegue (deployment) y ejecución en un sistema de destino. +- Tiene un fuerte conocimiento de los fundamentos de la informática, incluyendo estructuras de datos, grafos, máquinas finitas y algoritmos. + + +## :bust_in_silhouette: ¿Qué habilidades generales se esperan? + +- Es capaz de tomar decisiones basadas en su conocimiento técnico personal y los antecedentes de un proyecto. +- Entiende el concepto de soluciones "suficientemente buenas" (good enough) para evitar el exceso de ingeniería (overengineering). +- Tiene mentalidad de ser un jugador de equipo. +- Puede articular y compartir opiniones con otros miembros del equipo. +- Tiene experiencia trabajando con diversas metodologías como Kanban, Agile/Scrum, Waterfall, etc. +- Está dispuesto a ayudar y apoyar a otros miembros del equipo. + + +## :eyes: Consejos y recomendaciones + +### :arrow_forward: Estudiar + +- Mejorar las habilidades blandas (soft skills) es crucial si quieres convertirte en un desarrollador sénior. La experiencia técnica pasa a un segundo plano y la capacidad de construir relaciones y encontrar compromisos con los demás se vuelve más importante. Un buen desarrollador no es alguien que escribe mucho código, sino alguien que sabe cómo resolver un problema eficientemente con pérdidas mínimas. Idealmente, deberías poder resolver un problema sin escribir ningún código nuevo o incluso eliminar decenas o cientos de líneas de código. +- El rol middle es el más difícil de dominar. Tienes que concentrarte tanto en habilidades duras (hard skills) como blandas y en la resolución de problemas empresariales. Esto significa que debes concentrarte en ambos aspectos al mismo tiempo. +- Prestar atención a las habilidades blandas aumenta tus posibilidades de convertirte en un profesional muy buscado en el mercado. Puedes elegir centrarte en convertirte en un desarrollador altamente especializado e ignorar las habilidades blandas, pero ten en cuenta que tales especialistas no siempre tienen mucha demanda y la competencia entre ellos es extremadamente alta. Si estás listo para competir con los mejores especialistas del mercado, por todos los medios, adelante. Sin embargo, seguimos recomendando considerar la diversificación de tus habilidades. + +### :arrow_forward: Experiencia + +- Muchos desarrolladores middle caen en la trampa de convertirse en "fanboys" de tecnologías, frameworks, patrones de diseño o metodologías. Es importante ser más pragmático al resolver tareas en tu proyecto y no solo intentar adoptar las últimas ideas por el simple hecho de agregar otra habilidad a tu currículum. El rol middle puede llevar a un exceso de ingeniería o a un cambio constante de frameworks. +- Si crees que una biblioteca o framework es necesario para un proyecto, lo mejor es discutirlo con un ingeniero Sénior o Líder primero. Proponga crear una "prueba de concepto" (proof of concept) donde pueda probar todas sus hipótesis antes de agregar una nueva dependencia. No intentes hacer esto a espaldas de tu equipo, ya que podría resultar en mayores costos de mantenimiento y consecuencias imprevistas. + +--- + +[**Volver**](Overview.md) | [**Ir a la página principal**](../README.md) diff --git a/Spanish/Grades/Overview.md b/Spanish/Grades/Overview.md new file mode 100644 index 0000000..c6eee23 --- /dev/null +++ b/Spanish/Grades/Overview.md @@ -0,0 +1,33 @@ +# :chart_with_upwards_trend: Clasificación de desarrolladores + +> La clasificación (grading) es un enfoque para clasificar a los desarrolladores en función de sus habilidades y experiencia. A través de la clasificación, es posible comprender cómo diferenciar la dificultad de las tareas y el conjunto esperado de habilidades requeridas para manejarlas. + +Hoy en día, puedes encontrar el siguiente enfoque común de clasificación. Se pueden marcar los siguientes niveles: +- Junior; +- Middle; +- Senior. + +Cada empresa tiene su propia visión de la clasificación de desarrolladores y un conjunto de habilidades y responsabilidades declaradas para diferentes niveles. Es común encontrar la siguiente situación: puede ser promovido a un rol sénior en una empresa, pero en otra empresa podría ser evaluado como un desarrollador de nivel medio. A pesar de esto, es posible introducir expectativas comunes para cada nivel. Usaremos el enfoque simplificado descrito anteriormente para describir cada grado. + +**Ejemplo:** Puedes consultar este sitio web para obtener conocimiento sobre los sistemas de niveles en diferentes empresas: [levels.fyi](https://www.levels.fyi/) +| Level | Apple | Amazon | Google | Facebook | Microsoft | +|---|---|---|---|---|---| +| Junior | ICT2 | SDE I (L4) | L3 | E3 | SDE (59-60) | +| Middle | ICT3 | SDE II (L5) | L4 | E4 | SDE II (61-62) | +| Senior | ICT4 | SDE III (L6) | L5 | E5 | Senior SDE (63-64) | +| Staff | ICT5 | Principal SDE (L7) | L6 | E6 | Principal SDE (65-67) | +| Principal | ICT6 | Senior Principal (L8) | L7 / L8 | E7 / E8 | Partner (68-70) | +| Distinguished/Fellow | Distinguished / Fellow | Distinguished (L10) | L9 / L10 | E9 | Distinguished / Fellow | + + +## Descripciones de niveles + +Puedes leer estos artículos para comprender mejor cada nivel y sus expectativas comunes: +- :alien: [Pre-Junior C++](PreJunior.md) +- :yum: [Junior C++](Junior.md) +- :sunglasses: [Middle C++](Middle.md) +- :smiling_imp: [Senior C++](Senior.md) + +--- + +[**Ir a la página principal**](../README.md) diff --git a/Spanish/Grades/PreJunior.md b/Spanish/Grades/PreJunior.md new file mode 100644 index 0000000..7d147f4 --- /dev/null +++ b/Spanish/Grades/PreJunior.md @@ -0,0 +1,47 @@ +# :alien: Pre-Junior C++ + +## :question: ¿Quién es? + +Es alguien que está familiarizado con la sintaxis del lenguaje y puede escribir un programa simple sin el uso de bibliotecas de terceros. El programa realiza procedimientos sencillos como: +- operaciones aritméticas +- manipulación de archivos: ya sea de lectura o escritura +- esperar la entrada del teclado +- mostrar el resultado u otros datos en la consola +- etc. + +## :computer: ¿Qué habilidades de programación se esperan? + +- Crear y construir un pequeño proyecto C++ funcional utilizando uno de los IDE como Visual Studio o Qt Creator. +- Usar el depurador a través del IDE. +- Comprender el proceso de compilación y enlazado de un programa C++. +- Escribir una aplicación que haga uso de operaciones aritméticas y lógicas, condicionales y bucles. +- Escribir una aplicación que use los flujos (streams) estándar de entrada/salida. +- Manipular punteros y referencias. +- Conocer los tipos de memoria utilizados en una aplicación. +- Comprender la POO (OOP) básica en el contexto de C++, incluyendo la herencia, el polimorfismo y la encapsulación. + +## :bust_in_silhouette: ¿Qué habilidades generales se esperan? + +- Deseo de aprender y adquirir nuevos conocimientos. +- Deseo de resolver los problemas encontrados. +- Capacidad de formular una consulta para encontrar una solución a un problema utilizando un motor de búsqueda o la literatura relevante. + +## :eyes: Consejos y recomendaciones + +### :arrow_forward: Estudiar + +- No hay una solución única que te ayude a aprender C++ en un día, una semana o un mes. Prepárate para un proceso largo y autodirigido de aprendizaje de diversos materiales antes de que estés listo para aprobar una entrevista y asegurar tu primera oferta de trabajo. +- Si descubres que no entiendes cierto tema, busca recursos alternativos. +- ¡Practicar y solo practicar te permitirá dominar C++! Olvidarás la mayor parte de lo que lees o escuchas si no programas de manera regular. +- No intentes escribir código perfecto. Tu objetivo principal es escribir código que funcione y haga lo que se requiere. Necesitas aprender cómo comunicarte con la computadora. Esto es similar a aprender un idioma extranjero. Al principio, hablarás descuidadamente, pero a medida que perfecciones tus habilidades, tendrás una mejor comprensión de la gramática, ampliarás tu vocabulario, etc. +- No abordes un problema masivo de inmediato, como crear tu propio juego. Al principio, probablemente te falte el conocimiento y la experiencia para manejar la tarea por tu cuenta. Es probable que este enfoque se vuelva frustrante rápidamente y te lleve a la decepción en ti mismo y en tus habilidades, haciendo que abandones tu educación. Es mejor progresar de lo simple a lo complejo, desafiándote gradualmente con tareas cada vez más difíciles. +- No te centres en Leetcode, Codewars u otros recursos similares al principio. Estos portales están diseñados para mejorar tu capacidad de aplicar algoritmos clásicos y estructuras de datos. Sin embargo, al principio, estos ejercicios pueden no beneficiarte mucho ya que abstraen los detalles del lenguaje de programación. Es mejor centrarse en el lenguaje en sí y en sus capacidades. + +### :arrow_forward: Idioma inglés + +- Es más fácil encontrar soluciones en inglés, pero no te exijas demasiado si tu dominio del inglés no es lo suficientemente fuerte. Esto puede llevar rápidamente al desánimo. La mayoría de los problemas que puedas encontrar al principio se pueden buscar en tu idioma nativo. +- Si sientes que tu inglés no es suficiente, comienza a mejorarlo a través de medios más agradables: viendo series, jugando videojuegos, leyendo ficción o leyendo medios de noticias o artículos que te interesen. En unos pocos meses, deberías poder mejorar tus habilidades de comprensión en inglés. + +--- + +[**Volver**](Overview.md) | [**Ir a la página principal**](../README.md) diff --git a/Spanish/Grades/Senior.md b/Spanish/Grades/Senior.md new file mode 100644 index 0000000..c60ede7 --- /dev/null +++ b/Spanish/Grades/Senior.md @@ -0,0 +1,26 @@ +# :smiling_imp: Senior C++ + +## :question: ¿Quién es? + +Es un desarrollador que no solo comprende los aspectos técnicos, sino también el contexto comercial (business context). Son capaces de crear un diseño y una solución para un componente, aplicación o sistema, teniendo en cuenta ambos. Además, un Senior ayuda a otros miembros del equipo a crecer y se mantiene al día con los últimos desarrollos y tendencias en el mundo del desarrollo de software. + +## :computer: ¿Qué habilidades de programación se esperan? + +- Capacidad para traducir tareas del lenguaje comercial al lenguaje de desarrollo y descomponerlas. +- Capacidad para mantener un diálogo con el negocio y explicar los detalles técnicos y las dificultades a las partes interesadas no técnicas. +- Capacidad para no solo tomar decisiones de diseño, sino también crear la arquitectura de componentes y aplicaciones. +- Comprensión y uso de los principios arquitectónicos. + +## :bust_in_silhouette: ¿Qué habilidades generales se esperan? + +- Excelentes habilidades de comunicación. +- Capacidad para recopilar requisitos de forma independiente, si es necesario. +- Ayuda en el desarrollo de los miembros del equipo. + +## :eyes: Consejos y recomendaciones + +Dependiendo de las particularidades de la empresa y de tus propios objetivos, el camino para un mayor desarrollo profesional puede ser adquirir tecnologías recientes y habilidades técnicas dentro del campo de especialización elegido (por ejemplo, áreas especializadas de matemáticas, física, etc. - el camino de un experto técnico), o en el área de gestión e interacción interpersonal (como líder técnico, líder de equipo, gerente de proyectos, etc.). Elige sabiamente. 🙂 + +--- + +[**Volver**](Overview.md) | [**Ir a la página principal**](../README.md) diff --git a/Spanish/Graph/README.md b/Spanish/Graph/README.md new file mode 100644 index 0000000..c1415ad --- /dev/null +++ b/Spanish/Graph/README.md @@ -0,0 +1,33 @@ +# Cómo ver y editar la hoja de ruta + +[roadmap.drawio.svg](roadmap.drawio.svg) es una imagen SVG normal con un diagrama de [draw.io](https://www.drawio.com) incrustado: ábrela en cualquier lugar para ver el mapa. Es **generada**: el código fuente real es una descripción de texto neutral al idioma en [`tools/mapgen/roadmap/`](../../tools/mapgen/roadmap), por lo que este `.drawio.svg` es el resultado de la compilación, no lo que debes editar. + +## Visualización + +- En el sitio: [salmer.github.io/CppDeveloperRoadmap/goto/svg/?l=es](https://salmer.github.io/CppDeveloperRoadmap/goto/svg/?l=es) +- En GitHub: abre [roadmap.drawio.svg](roadmap.drawio.svg) — se renderiza como una imagen. +- Interactivamente: el [visor de draw.io](https://salmer.github.io/CppDeveloperRoadmap/goto/drawio/?l=es) (solo lectura — los cambios allí no se guardan). + +## Edición + +El mapa se construye a partir de `tools/mapgen/roadmap/` — `structure.dsl` (el árbol de nodos, grados, etapas, cuadros de sugerencias) y un `.tsv` por idioma (solo el texto). **No edites este `.drawio.svg` a mano** — se regenera a partir de la fuente, y el CI (`mapcheck`) rechaza un mapa que se haya desviado de ella. + +1. Haz un fork del repositorio y edita la fuente: + - un nodo, su grado/etapa, o una sugerencia → `tools/mapgen/roadmap/structure.dsl` + - el texto (una etiqueta, una sugerencia, la fecha) → la fila correspondiente en `en.tsv` / `ru.tsv` / `zh.tsv` / `es.tsv` + (un nuevo nodo necesita una fila en **todos ellos**). +2. **Solo la primera vez** — prepara tu máquina: + ```bash + python tools/mapgen/setup.py --venv + ``` + Crea un virtualenv, instala Pillow y verifica las dos cosas que no puede instalar por ti (una fuente CJK y la aplicación de escritorio draw.io), imprimiendo el comando exacto para tu sistema operativo si falta alguna. +3. Reconstruye, actualiza todos los mapas y valida — un comando desde la raíz del repositorio: + ```bash + python tools/mapgen/build.py --dir tools/mapgen/roadmap --deploy --check + ``` + `--deploy` copia cada mapa construido sobre su `/Graph/roadmap.drawio.svg`; + `--check` ejecuta `mapcheck` después. Las dependencias se vuelven a verificar antes de construir nada, por lo que una faltante — o un virtualenv que olvidaste activar — se informa por adelantado. +4. Abre un pull request con la fuente **y** los mapas regenerados. + +Consulta [`tools/mapgen/README.md`](../../tools/mapgen/README.md) para la gramática del DSL y detalles. +¿No puedes ejecutar la compilación? Edita la fuente de todos modos y anótalo en tu PR — un mantenedor regenerará los mapas. diff --git a/Spanish/Graph/roadmap-svg.md b/Spanish/Graph/roadmap-svg.md new file mode 100644 index 0000000..007e5a4 --- /dev/null +++ b/Spanish/Graph/roadmap-svg.md @@ -0,0 +1,4 @@ +--- +layout: svg_viewer +title: C++ Developer Roadmap (Español) +--- diff --git a/Spanish/Graph/roadmap.drawio.svg b/Spanish/Graph/roadmap.drawio.svg new file mode 100644 index 0000000..ddc3075 --- /dev/null +++ b/Spanish/Graph/roadmap.drawio.svg @@ -0,0 +1,4 @@ + + + +Paso 1Paso 2Paso 3Paso 4Paso 1Paso 3Paso 5Paso 1Paso 4Paso 2Desarrollador C++Habilidades blandasCapacidad de aprendizajeHacer las preguntas correctasProcesar informaciónExperimentaciónGestionar el conocimientoGestionar erroresAnalizar erroresAdmitir los erroresNotificar los errores a tiempoAceptar críticasPensamientoLógicoSistémicoCríticoCreativoEstratégicoResponsabilidadDisciplinaPersistenciaIniciativaIndependenciaResolución de problemasGestión de recursosGestión del tiempoPriorizaciónToma de decisionesMecanografía al tactoMultitareaComunicaciónNegociaciónCapacidad de escuchaPersuasiónCapacidad para comunicar ideas y pensamientos dentro del equipoProporcionar información a personas fuera del equipoEncontrar compromisosResolución de conflictosInglésPresentaciónHabilidad de comunicación escritaNetworkingTrabajo en equipoEntender la distribución de roles en un equipoApoyar a los miembros del equipoTrabajar en un equipo distribuidoProporcionar retroalimentaciónLiderazgoAsignar y aclarar tareas a los empleadosPlanificación y establecimiento de objetivosMentoríaDelegaciónInteligencia emocionalResistencia al estrésTrabajar en la incertidumbreAdaptabilidadMente abiertaConcentraciónEmpatíaEntender el contexto de desarrolloEnfoque en el clienteTecnologíaTendenciasHabilidades durasSintaxis del lenguajeOperaciones básicasOperaciones aritméticasOperaciones lógicasBucles: for/whileOperaciones a nivel de bitsFuncionesOperadoreslambdaTipos de datosTipado estáticoTipado dinámicoRTTIPunteros y ReferenciasReferenciasPunteros inteligentesunique_ptrshared_ptrweak_ptrModelo de memoriaTiempo de vida de los objetosPunteros crudosOperadores new/deleteFugas de memoriaEstructuración del códigoDivisión de código en archivos headers/cppDeclaración anticipadaÁmbito (Scope)Espacios de nombres (Namespaces)Estructuras y clasesProgramación Orientada a Objetos (POO)Polimorfismo estáticoSobrecarga de funcionesPolimorfismo dinámicoMétodos virtualesTabla virtual (vtbl)La regla de cero/tres/cincoHerencia múltipleHerencia en diamanteManejo de excepcionesstd::optional / std::expectedExcepcionesViolación de accesonoexceptCódigos de errorstd::error_codeConceptos del lenguajeauto (deducción automática de tipos)Conversión de tipos (type casting)static_castconst_castdynamic_castreinterpret_castComportamiento indefinido (UB)Búsqueda dependiente de argumentos (ADL)constexpr / constevalMacrosName manglingSemántica de movimientoCategorías de valores (lvalue/rvalue)std::move / std::forwardReenvío perfecto (perfect forwarding)Corrutinas (C++20)Módulos (C++20)Biblioteca estándar + STLiostreamstd::format / std::printFecha/horaContenedoresstd::span / std::string_viewIteradoresAlgoritmosstd::rangesMultihiloPlantillas (Templates)Plantillas variádicasEspecialización de plantillasEspecialización completa de plantillasEspecialización parcial de plantillastype traitsSFINAEConceptos (C++20)Idiomatismos (Idioms)RAIIpimplNo copiable/No movibleErase-RemoveCopy and swapCopy on writeCRTPEstándaresC++11/14C++17C++20C++23C++26 (más reciente)Herramientas del lenguajeTrabajar con código fuenteEditores de textoIDEEditores de códigoConocimiento de características y habilidades (atajos, herramientas, plugins)Depurador (Debugger)Comprensión de los mensajes del depuradorSímbolos de depuraciónWinDbgGDBLLDBLintersCompiler Explorer (godbolt.org)CompiladoresComprensión básica de las etapas de compilaciónCompilación de código fuente a archivos objeto (compilación)Enlazado de archivos objeto (linking)Etapas de trabajo de los compiladoresCaracterísticas de un compilador en particularSistemas de compilación (Build systems)CMakeMakefileninjaGestores de paquetesConannugetvcpkgspackTrabajar con bibliotecasInclusión de bibliotecasLicenciamientoBibliotecasboostopencvpocoprotobufAsiogRPCfmtnlohmann/jsonpybind11spdlogrange-v3tensorflowopenclFrameworksgtest/gmockQtcatch2google benchmarkgoogle profilerpytorch c++Habilidades comunesCiencias de la ComputaciónEstructuras de datosÁlgebra booleanaAlgoritmosMáquinas de estados finitosSoftware de control de versionesDistribuidogitMercurialCentralizadoSVNMejores prácticasCalidad del códigoGuías de códigoPrincipios de desarrolloKISS (Keep It Simple, Stupid)DRY (Don't Repeat Yourself)YAGNI (You Aren't Gonna Need It)APO (Avoid Premature Optimization)BDUF (Big Design Up Front)La composición es preferible a la herenciaNavaja de OckhamDivide y vencerásRegistro (Logging) y telemetríaRevisión de códigoHabilidad para leer código fuente existenteHabilidad para revisar códigoEtapas del ciclo de vida del softwareImplementaciónPruebas (Testing)Pruebas unitariasPruebas de integraciónPruebas funcionalesPruebas de rendimientoMantenimientoControl de versionesCompatibilidad hacia atrásDiseño de arquitectura de software y componentesIntegración de componentesDespliegue (Deployment)Recopilación de requisitosFin del ciclo de vida del softwareAnalizadores de códigoAnalizadores estáticosAnalizadores dinámicosPerfiladores (Profilers)Valgrindperf / VTuneC++ core guidelinesMicrosoft GSLEstándares industrialesMISRA C++:2023AutosarEU Cyber Resilience Act (CRA)SBOMIEC 62304 (medical)ISO 26262 (automotive)DO-178C (avionics)Línea de comandosPowershellbatchbashCI/CDCreación de un paquete de despliegue de softwareDocumentaciónPaquete instaladorTrunk Based DevelopmentDespliegue sin tiempo de inactividadHerramientas de IAAsistentes de IA (Copilot, Claude Code, Cursor)Verificación de código generadoPolítica de la empresa y confidencialidadRiesgos de licencias del código generadoModelos localesUso de otros lenguajes de programaciónInteroperabilidad de lenguajesDiseño de softwarePatrones de diseño (GoF)EstructuralesDe comportamientoCreacionalesPOOSOLIDUMLEstilos de arquitecturaBasado en componentesAplicación monolíticaPor capasCliente-servidorArquitectura de microserviciosBasado en eventosPluginsRESTArquitectura orientada a servicios (SOA)Patrones de arquitecturaMVCMVVMTres niveles (Three-tier)Cebolla (Onion)Hexagonal (Hexagon)Metodologías de desarrolloTest Driven Development (TDD)Behavior Driven Development (BDD)Domain Driven Design (DDD)Sistemas operativosUnidades binariasArchivo ejecutableBiblioteca estáticaBiblioteca dinámicaMemoriaAbstracciones de memoriaPila (Stack)Montículo (Heap)Memoria globalMemoria de la aplicaciónAlineación de memoriaGestión de memoriaMemoria virtualHilos (Threads)MultihiloErroresInterbloqueo (Dead lock)Condición de carrera (Race condition)Live lockInanición (Starvation)std::atomic, modelo de memoria de C++ConcurrenciaMutexesSemáforoslock-freecondition_variablefuture / promise / asyncjthread (C++20)Manejo de eventosSíncrono (Sync)Asíncrono (Async)OpenMP / TBBProcesoComunicación entre procesos (IPC)Memoria compartidaTuberías (Pipes)SerializaciónjsonXMLRedesTCP/IPSocketsTCPUDPHTTPOSISistema de archivosProgramador de tareasVirtualizaciónVirtualBoxVMware WorkstationHyper-VContenedoresDockerKubernetesServicios en la nubeSeguridadVulnerabilidades: desbordamiento de búfer, use-after-freeSanitizers (ASan / TSan / UBSan)CifradoFuzzingCERT C++ / CWESistemas MultiCPUCPU multinúcleoNUMAEntrada/salida (I/O)Controladores (Drivers)AudioDirectSoundOpenALGráficosDirectXOpenGLVulkanCUDAImpresoras (impresión)La sobrecarga de un conjuntoregular de operadores paratipos regulares opersonalizados(estructuras/clases).Para prevenir problemas defugas de memoria, es mejorusar punteros inteligentes enlugar de punteros crudos.Se prefiere evitar la herenciamúltiple (exceptuando lasclases abstractas) paraprevenir problemas en tiempode ejecución.Algunas construcciones dellenguaje tienen uncomportamiento no declaradosegún el estándar ISO. En casode cualquier error, no esposible predecir elcomportamiento futuro.Depende del entorno de laplataforma, el contexto deejecución, etc.Capacidad para reunir,analizar, evaluar información ytomar decisiones basadas enella.Elige uno de los IDEspopulares y estúdialo bien: MSVisual Studio, VS Code, QtCreator, JetBrains CLion,XCode, etc.Elige uno de los editorespopulares y estúdialo bien. Porejemplo: Notepad++, SublimeText, etc.Elige uno de los editorespopulares y estúdialo bien. Porejemplo: VS Code, SublimeText, Zed, etc.Aprende sobre errorescomunes (segfault, memoriaagotada, violación de acceso)y el concepto decomportamiento indefinido.Reflexión (Reflection)Estudia cómo usar undepurador y todas suscaracterísticasLa capacidad de trabajar conun depurador a través de lalínea de comandos no es unahabilidad común. Es suficientetrabajar con él a través del IDE.Por ejemplo: establecer puntosde interrupción condicionales,etc.Reacciona con calma a lo quedice la gente. Lo más probablees que solo consideren supropio contexto cuandointentan probar algo. Esto estábien. Evalúa la utilidad de supunto de vista.El compilador realiza variasetapas de compilación decódigo. Es bueno conocerlastodas para entender mejor losproblemas de compilación. Elconocimiento profundo esnecesario solo para loscreadores de compiladores.Toma tareas desafiantes paradesarrollar tus habilidades ycompetencias, incluso cuandono haya suficienteconocimiento/experiencia (lashabilidades se desarrollaránmucho más rápido a través detales tareas). Lo principal esdistinguir una tarea complejarealmente útil que te ayudará aimpulsar tus habilidades deuna tarea inútil que requiereun chivo expiatorio.Cada compilador tiene susmatices. Es bueno conocerlospara evitar caer en cualquiertrampa: Clang++/LLVM, IntelC++, MSVS C++, GCC, MinGWDebes ser responsable de tudesarrollo profesional. Noesperes a que el líder delequipo decida por ti quéestudiar. No olvides que laadhesión ciega al plan de otrapersona afilará tus habilidadessegún los requisitos de unaempresa en particular. Esmejor discutir e incorporar tusintereses en el plan. Si esto nose hace, existe un alto riesgode obtener habilidadesirrelevantes, lo que afectará lasoportunidades profesionales.Pero no exageres: no estudiesabsolutamente todo o noesperes pasivamente hasta quese cree un plan de desarrollopara ti.Lee cuidadosamente lostérminos del acuerdo delicencia. Tu proyecto debecumplirlos.Auto-organizaciónLa capacidad de proporcionarla cantidad de informaciónnecesaria para comunicarsecon personas de diferentestrasfondos.Al principio, algunas de lashabilidades pueden parecerimposibles de desarrollar. Sinembargo, pensamos diferente.Es posible trabajar en cada unade las habilidades. Tododepende de tu deseo ybloqueos internos. Todo esindividual, y depende de tidecidir. :)Resolución de conflictosSi lees esto significa que yaentiendes por qué es tanimportante :) Usualmente, serequiere al menos para leerporque necesitarías entenderla documentación técnica.Pero a medida que avanzas enla escala profesional,necesitarás hablar y escribircon más confianza en inglés.Busca personas con ideasafines y únete o crea unacomunidad para elintercambio de experiencias.También es bueno saber cómocalcular la complejidad de losalgoritmos y el consumo dememoria.Debes estudiar y observar lastendencias contemporáneaspara ser competitivo, así comopoder adaptarte a ellas.Los desarrolladoresexperimentados debendesarrollar habilidades degestión y habilidades decomunicación comercial paracompletar las tareas demanera eficiente. Es más fácilde hacer si has desarrollado lainteligencia emocional. Para undesarrollador junior, lahabilidad también es útil parainteractuar mejor con loscolegas.Para configurar la verificaciónautomatizada del formato delcódigo con una de lasutilidades adecuadas:clang-format, Resharper -code style, MSVS - code style.Convenciones denomenclatura, pestañas vsespacios, etc.No ignores las advertenciasdel compilador y delanalizador estático. Son tusamigos, no tus enemigosLa IA puede generar códigoplausible pero incorrecto —verifica y prueba todo. Serequiere conocimiento deC++.- Scripting - Funcional - TipoSQL - NoSQLA veces es necesarioproporcionar una habilidadpara reutilizar una bibliotecaescrita en un lenguajediferente desde otro. Porejemplo: para llamar abibliotecas C++ en C#.Los requisitos de seguridad dela memoria están aumentando(reguladores de EE. UU. y laUE). Aprende prácticas segurasy herramientas de análisis.
Hoja de ruta del desarrollador C++
Última actualización: 2026-09-02
Acerca de:
C++ sigue siendo uno de los lenguajes de desarrollo más populares. Hay bastantes personas que quieren empezar a aprenderlo y convertirse en un desarrollador C++. Se enfrentan a preguntas como: "¿Por dónde debería empezar? ¿Qué y en qué orden debería estudiar? ¿Qué libros debería leer?". Intentamos responder a estas preguntas en la hoja de ruta presentada. El mapa se centra en las competencias y habilidades generales que se podrían encontrar en la mayoría de los proyectos. Está diseñado para ayudar a aquellos que recién comienzan su educación o tienen poca experiencia. Puedes crear un plan de aprendizaje más productivo sin distraerte con información paralela si estudias el conjunto de materiales enumerados. Te ayudará a dominar C++ al nivel que se usa en muchos proyectos comerciales.
Repositorio:
https://github.com/salmer/CppDeveloperRoadmap
Cómo usar:
Comentarios:
Los juniors deben conocer las habilidades de los middle/senior. Es suficiente tener una comprensión básica de ellas.
El desarrollador middle tiene las habilidades para crear un diseño para nuevas funcionalidades como parte de un componente/aplicación incluso si no hay suficientes requisitos o información presentada.
Opcional
Si tienes algún comentario u observación, no dudes en contactarnos. Realmente lo apreciamos. :) Para contactarnos, elige uno de los siguientes enfoques de Github: - Para cualquier observación relacionada con el contenido del repositorio - ve a Pull Requests y envía uno nuevo
Senior
Middle
Junior
El junior debe adquirir la siguiente habilidad lo antes posible: escribir código fácil de leer y bien estructurado.
Los "pasos" se presentan en este mapa. Su intención es mostrar una base fácil para que los novatos puedan obtener conocimientos básicos de confianza sobre el lenguaje al principio.
El desarrollador senior tiene las habilidades para crear un diseño y tomar decisiones para una solución/componente teniendo en cuenta el contexto del área de negocio.
Text is not SVG - cannot display \ No newline at end of file diff --git a/Spanish/HowToStudy.md b/Spanish/HowToStudy.md new file mode 100644 index 0000000..2e52914 --- /dev/null +++ b/Spanish/HowToStudy.md @@ -0,0 +1,35 @@ +# :mortar_board: ¿Cómo estudiar? + +El consejo principal que se puede dar es que debes comprender que eres el único responsable de tu propio desarrollo. Por supuesto, te cruzarás con muchos entusiastas que estarán felices de ofrecerte consejos, pero nadie creará tareas específicas o programas de entrenamiento para ti. Tus mejores amigos en este proceso serás tú mismo, la búsqueda en Google y los tutoriales. + +## :question: ¿Cómo estudiar los nuevos estándares C++ 11/14/17/20? + +Los principiantes no deberían centrarse demasiado en los estándares al comienzo de su viaje. Se recomienda elegir libros de la [Lista para Principiantes](Books/PreJunior.md) y aprender los fundamentos. Los libros modernos para principiantes suelen contener información limitada sobre las capacidades de C++11 y los estándares más nuevos. Al principio, es mejor no centrarse en los nuevos estándares del lenguaje. + +Es importante comprender por qué los estándares modernos se centran principalmente en solucionar problemas, proporcionar "azúcar sintáctico" y presentar nuevas funcionalidades. Solucionar problemas y proporcionar azúcar sintáctico es sencillo; se introducen nuevas construcciones para corregir problemas en estándares anteriores, y nuevas abstracciones para simplificar el código repetitivo. Sin embargo, con la nueva funcionalidad, es un poco más complicado. + +C++, al igual que otros lenguajes, evoluciona incorporando ideas populares de las ciencias de la computación y características exitosas de otros lenguajes. Es importante estudiar tales construcciones y usarlas según sea necesario, pero primero, es crucial estudiar las bases que fueron establecidas por los estándares más antiguos (C++11/C++14), que se describen en la mayoría de los libros modernos para principiantes. + + +## :question: ¿Dónde obtener una descripción general de las características de los últimos estándares de C++? + +- Presentaciones en [conferencias de C++](CommunitySources.md) +- En la página principal de [CppReference](https://en.cppreference.com/w/cpp) encontrarás enlaces a páginas con listas de resumen de las características más nuevas. +- Puedes leer el siguiente libro de [Bjarne Stroustrup - A Tour of C++ (3rd Edition, covers C++20)](https://www.amazon.com/Tour-C-Depth/dp/0136816487). Revisa regularmente el libro para ver si hay actualizaciones, ya que se revisa con cada nueva versión del estándar de C++. +- Foros/chats/discusiones profesionales, etc. +- Videos de resumen en YouTube por parte de la comunidad. +- [A cheatsheet of modern C++ language and library features](https://github.com/AnthonyCalandra/modern-cpp-features) + +## :eyes: Recomendaciones de entrenamiento + +- ¡Aprende a tu propio ritmo, sin importar la edad que tengas! No te desanimes por las historias de "Soy programador desde que nací". La mayoría de estas historias son un ejemplo del [sesgo del superviviente](https://es.wikipedia.org/wiki/Sesgo_del_superviviente) o un intento de halagar su vanidad a tu costa. ¡Tienes la capacidad de aprender a programar desde cero, incluyendo C++! +- Cuando te enfrentes a problemas, es recomendable buscar soluciones en internet, ya que la mayoría de los problemas que encuentres probablemente ya estén resueltos. Si no puedes encontrar la respuesta, intenta reformular tu solicitud de una manera diferente. Si aún no encuentras la solución, intenta simplificar el problema. +- Es importante centrarse en aprender el lenguaje en lugar de luchar con el entorno de trabajo, ya que esto puede generar frustración y pérdida de motivación. +- Ten en cuenta que incluso los desarrolladores experimentados encuentran problemas y pueden atascarse, por lo que tomar un descanso y volver a la tarea más tarde es una buena idea. +- Encontrar personas con ideas afines que también estén comenzando su camino de aprendizaje puede hacer que el proceso sea más agradable, ya que pueden compartir conocimientos y experiencias entre ustedes y desarrollar habilidades de trabajo en equipo. En el mundo de hoy, casi en todas partes tendrás que trabajar en equipo, por lo que es útil desarrollar estas habilidades. +- Tener un mentor experimentado también puede ser valioso, ya que puede guiarte para evitar errores comunes y ahorrarte tiempo. + + +--- + +[**A la página principal**](README.md) diff --git a/Spanish/Libraries.md b/Spanish/Libraries.md new file mode 100644 index 0000000..f5400d0 --- /dev/null +++ b/Spanish/Libraries.md @@ -0,0 +1,83 @@ +# :package: Bibliotecas y frameworks populares + +C++ no tiene un ecosistema único "estándar" como npm en JavaScript o crates.io en Rust, por lo que el conjunto de bibliotecas en uso depende en gran medida del dominio. Aun así, hay algunos nombres que aparecen en las ofertas de trabajo y en los proyectos con más frecuencia que el resto, y esos son los que se recopilan a continuación. + +No intentes aprender todo a la vez. Es mucho más útil sentirse realmente cómodo con una o dos bibliotecas de tu propio campo que conocer una docena superficialmente. La forma más sencilla de incorporarlas es a través de los gestores de paquetes Conan o vcpkg: consulta el [Conjunto de herramientas del lenguaje](Tooling.md). + +> :compass: Este es un artículo de descripción general y un punto de partida para la navegación, no un catálogo completo. La cantidad de bibliotecas que existen realmente es de órdenes de magnitud mayor, y para cualquier tarea específica casi siempre hay algo más por ahí: busca dentro de tu propio dominio de problemas, mira qué usan proyectos similares y verifica las listas actualizadas (por ejemplo, [awesome-cpp](https://github.com/fffaraz/awesome-cpp)). El objetivo de esta lista es dar un punto de apoyo a aquellos que recién están comenzando. + +> :bulb: Las herramientas de desarrollo (compiladores, depuradores, analizadores, frameworks de pruebas) están cubiertas en un artículo separado: [Conjunto de herramientas del lenguaje](Tooling.md). + +## :hammer_and_wrench: Propósito general + +* :arrow_forward: **Boost** - [boost.org](https://www.boost.org) + + Una gran colección de bibliotecas que históricamente ha servido como un "campo de pruebas" para la biblioteca estándar: gran parte de lo que hoy forma parte del estándar (smart pointers, `filesystem`, `optional`, `variant`) se probó por primera vez en Boost. Todavía es útil ahora: contiene cosas de las que el estándar aún carece. La otra cara de la moneda es el tamaño: incorporar todo Boost por el bien de una función es una mala idea; la mayoría de sus bibliotecas se pueden tomar por separado. + +* :arrow_forward: **{fmt}** - [github.com/fmtlib/fmt](https://github.com/fmtlib/fmt) + + Una biblioteca de formato de cadenas que se convirtió en la base de `std::format` en C++20. Más rápida y segura que `printf`, más legible que los flujos (streams) de `iostream`. Tiene sentido si tu compilador aún no soporta `std::format` o si necesitas capacidades más allá del estándar. + +* :arrow_forward: **spdlog** - [github.com/gabime/spdlog](https://github.com/gabime/spdlog) + + Una biblioteca de registro (logging) rápida construida sobre {fmt}. Soporta la salida a archivos con rotación, a una consola con resaltado y un modo asincrónico. El registro es una de las principales herramientas de diagnóstico en producción, cuando adjuntar un depurador (debugger) es imposible. + +* :arrow_forward: **range-v3** - [github.com/ericniebler/range-v3](https://github.com/ericniebler/range-v3) + + La implementación de referencia en la que se basó `std::ranges` en C++20. Te permite escribir transformaciones de secuencias como una cadena, sin iteradores explícitos ni contenedores temporales. Es relevante si necesitas funciones que aún no han llegado al estándar o soporte para compiladores más antiguos. + +## :globe_with_meridians: Redes e intercambio de datos + +* :arrow_forward: **Asio** - [think-async.com/Asio](https://think-async.com/Asio/) + + El estándar de facto para la E/S asincrónica en C++ y la base de muchos proyectos de red. Existe en dos variantes: como una biblioteca independiente y como parte de Boost. Funciona bien con corrutinas de C++20. Sobre su base se ha propuesto repetidamente una biblioteca de red para el estándar. + +* :arrow_forward: **nlohmann/json** - [github.com/nlohmann/json](https://github.com/nlohmann/json) + + La biblioteca más popular para trabajar con JSON en C++. Se valora por el hecho de que el código que la usa se ve casi como un lenguaje con soporte JSON integrado. Se incorpora como un solo archivo de encabezado (header). Si la velocidad de análisis en grandes volúmenes es crítica, vale la pena considerar alternativas más rápidas como simdjson o RapidJSON. + +* :arrow_forward: **Protocol Buffers** - [protobuf.dev](https://protobuf.dev) + + Un formato de serialización binaria basado en esquemas de Google: la estructura de datos se describe en un archivo separado, a partir del cual se genera el código. Más compacto y más rápido que JSON, y el esquema brinda control sobre la compatibilidad de versiones, una propiedad importante cuando el cliente y el servidor no se actualizan al mismo tiempo. + +* :arrow_forward: **gRPC** - [grpc.io](https://grpc.io) + + Un framework de llamadas a procedimientos remotos sobre Protocol Buffers y HTTP/2. Está muy extendido en las arquitecturas de microservicios, incluidas las configuraciones donde los servicios están escritos en diferentes lenguajes. + +* :arrow_forward: **POCO** - [pocoproject.org](https://pocoproject.org) + + Un conjunto de bibliotecas multiplataforma para aplicaciones en red y de servidor: un cliente y servidor HTTP, acceso a bases de datos, análisis de XML y JSON, registro (logging). En espíritu, está más cerca de "baterías incluidas" que de un conjunto de bibliotecas específicas. + +## :framed_picture: Interfaz gráfica de usuario + +* :arrow_forward: **Qt** - [qt.io](https://www.qt.io) + + El framework más extendido para aplicaciones de escritorio en C++, que hace mucho tiempo superó los límites de una GUI: incluye redes, bases de datos, hilos (threads) y análisis de formatos. Es multiplataforma, con su propio IDE (Qt Creator). Un matiz importante es la licencia: la versión abierta se distribuye bajo LGPL/GPL, y un producto comercial cerrado puede requerir una licencia paga. Vale la pena estudiar los términos **antes** de comenzar el desarrollo. + +## :bar_chart: Computación, gráficos y aprendizaje automático + +* :arrow_forward: **OpenCV** - [opencv.org](https://opencv.org) + + El estándar de facto en visión por computadora: procesamiento de imágenes y videos, detección de objetos, calibración de cámaras. Se utiliza en robótica, control de calidad industrial e imágenes médicas. + +* :arrow_forward: **Eigen** - [libeigen.gitlab.io](https://libeigen.gitlab.io/) + + Una biblioteca de álgebra lineal: matrices, vectores, resolución de sistemas de ecuaciones. Consta solo de archivos de encabezado y está agresivamente optimizada. Aparece a menudo en robótica, simulaciones y visión por computadora. + +* :arrow_forward: **CUDA** - [developer.nvidia.com/cuda-toolkit](https://developer.nvidia.com/cuda-toolkit) y **OpenCL** - [khronos.org/opencl](https://www.khronos.org/opencl/) + + Dos enfoques de computación en tarjetas gráficas. CUDA se ejecuta solo en hardware NVIDIA pero es más maduro y conveniente; OpenCL es un estándar abierto que funciona en hardware de varios proveedores. Tienen demanda cuando una tarea se paraleliza bien: computación científica, procesamiento de imágenes, aprendizaje automático. + +* :arrow_forward: **LibTorch (PyTorch C++)** - [pytorch.org/cppdocs](https://pytorch.org/cppdocs/) y **TensorFlow** - [tensorflow.org](https://www.tensorflow.org) + + Las API de C++ de los dos principales frameworks de aprendizaje automático. El entrenamiento del modelo generalmente se realiza en Python, mientras que C++ se usa en la etapa de implementación: cuando un modelo terminado necesita ejecutarse dentro de una aplicación con requisitos de velocidad estrictos o sin depender de Python. + +## :link: Interoperabilidad con otros lenguajes + +* :arrow_forward: **pybind11** - [github.com/pybind/pybind11](https://github.com/pybind/pybind11) + + Te permite convertir el código C++ en un módulo importable en Python. El escenario típico: la computación pesada está escrita en C++, mientras que la lógica de nivel superior y los experimentos se quedan en Python. Los envoltorios (wrappers) de muchos proyectos conocidos están basados en pybind11. + +--- + +[**A la página principal**](README.md) diff --git a/Spanish/Mythbusters.md b/Spanish/Mythbusters.md new file mode 100644 index 0000000..0978b7f --- /dev/null +++ b/Spanish/Mythbusters.md @@ -0,0 +1,49 @@ +# :ghost: Mitos y Leyendas de C++ + +## :question: C++ está muerto, es imposible programar algo con él + +C++ no está muerto. + +De hecho, se ha mantenido consistentemente entre los lenguajes de programación principales en varias clasificaciones, como el índice [Tiobe](https://www.tiobe.com/tiobe-index/). La percepción de que C++ es un "lenguaje muerto" surgió a principios de los años 2000, cuando el comité de estandarización del lenguaje estaba inactivo. Sin embargo, C++ ha experimentado un resurgimiento desde entonces, añadiéndose nuevas características y funcionalidades cada tres años desde el estándar C++11. A pesar de esto, todavía hay quienes perpetúan los mitos y leyendas de que C++ es un lenguaje difícil y problemático, a menudo porque no se han mantenido al día con los desarrollos del lenguaje o solo han tenido una exposición limitada a él en su educación. + +## :question: Los programadores de verdad aprenden C++ usando Linux/Vim/gcc + +Si no estás familiarizado con la combinación mencionada, se recomienda centrarse en aprender los fundamentos de C++ primero. Se sugiere comenzar a desarrollar tus primeras aplicaciones utilizando el IDE Microsoft Visual Studio. Para más información, consulta los [Libros PreJunior](Books/PreJunior.md). + +Tomar el camino desafiante puede parecer genial, pero hay una alta probabilidad de que la cantidad de información necesaria para crear un programa "Hello World" usando Linux, Vim y GCC sea abrumadora. Esto podría llevar a una frustración temprana y a la desilusión con la programación en general. Intenta seguir un camino que comience con cosas simples y aumente gradualmente en complejidad. Al igual que un novato no debería intentar levantar los pesos más pesados durante su primer entrenamiento, la misma regla se aplica al aprendizaje. Una vez que te sientas cómodo con el lenguaje, puedes intentar desarrollar usando Linux. Pero esa es otra historia completamente distinta... + +## :question: Es mejor dominar C/Ensamblador/etc. antes de aprender C++ + +¡No, no y no de nuevo! + +Esta afirmación persiste debido a dos escenarios generalizados: es cómo se enseñaba C++ en las universidades en el pasado, y los miembros de la "Vieja Guardia" pasaron por un camino similar. El C++ moderno no requiere un enfoque tan desafiante. El lenguaje es autosuficiente y se puede aprender sin ninguna base previa. Es más probable que aprender C++ a través del enfoque "C -> C++" resulte en confusión y en un deseo de escribir C++ en un estilo de "C con clases". + +## :question: Aprende C++ usando el libro de Stroustrup + +Una afirmación muy perjudicial que proviene de la "Vieja Guardia" o de aquellos que nacieron con un teclado en la mano. + +Este consejo probablemente lo den aquellos que tienen amplia experiencia en el desarrollo de otros lenguajes (como C, Fortran, Delphi, etc.) y luego hicieron la transición a C++. Stroustrup escribió el libro [The C++ Programming Language](https://www.amazon.com/C-Programming-Language-4th/dp/0321563840) como una referencia, por lo que debe usarse de manera adecuada, lo cual requiere cierto conocimiento del lenguaje. En cambio, es mejor consultar la sección de [Libros](Books/Overview.md), donde encontrarás libros para todos los niveles de dominio del lenguaje. + +## :question: Aprende C++ usando solo el Estándar + +Otra afirmación esnob. + +El estándar moderno de C++, que supera las 2000 páginas, requiere pago para acceder a la versión actualizada y no está compuesto de manera fácil de usar. Si bien es elogiable para aquellos que aprendieron el lenguaje usando su estándar, no se recomienda como una forma de aprender para la mayoría de las personas. En cambio, es mejor revisar la sección de [Libros](Books/Overview.md), donde encontrarás libros adecuados para varios niveles de dominio del lenguaje. + +## :question: El Comportamiento Indefinido (Undefined Behavior) acecha al desarrollador en todas partes + +Más probablemente no que sí. + +El C++ moderno y las herramientas que han surgido alrededor del lenguaje permiten evitar la gran mayoría de los problemas relacionados con el comportamiento indefinido (Undefined Behavior). Podemos dar un consejo sencillo: cuando no estés seguro de lo que hace una construcción en particular, lee sobre ella en [CppReference](https://en.cppreference.com), [StackOverflow](https://stackoverflow.com/) u otros recursos dedicados. Si aún tienes dudas después de leer, intenta reescribir el código de una manera más sencilla para evitar el comportamiento indefinido. Hay un gran poder en la simplicidad. + +## :question: Uno necesita gestionar la memoria manualmente, no hay recolección de basura (garbage collection) en el lenguaje + +Esta es otra leyenda urbana de la "Vieja Guardia", que dejó de escribir C++ antes de C++11 o de aquellos que lo aprendieron superficialmente en la universidad y pasaron por alto los estándares más recientes. El C++ moderno tiene un conjunto de primitivas en su biblioteca estándar que son responsables de la asignación y desasignación automática de memoria. La gestión manual de memoria ha quedado en el camino. Muchos equipos y empresas incluso tienen la regla: "Cero punteros crudos" (No raw pointers). Una vez más, no descuides las herramientas modernas y los sanitizers, ya que pueden detectar posibles fugas de memoria a nivel de código fuente. + +## :question: C++ es solo para áreas heredadas (legacy) + +Parcialmente es cierto, pero vale la pena señalar que no solo es aplicable a C++. La calidad del código en cualquier lenguaje depende principalmente de la cultura técnica de un equipo y sus pioneros, no solo del lenguaje. La mayor parte del código heredado se produce debido a factores humanos: el nivel de habilidad del desarrollador, su ética de trabajo y estimaciones incorrectas, entre otros. Hoy en día, hay muchos proyectos escritos en C++ que han estado funcionando 24/7 durante años y son la base de los ingresos de una empresa. En tales casos, es peligroso realizar cambios significativos en un corto período. Los desarrolladores tienen mucho cuidado al hacer cambios para evitar regresiones. Sin embargo, no pienses que trabajar en proyectos heredados no puede ayudarte a mejorar. De hecho, estos proyectos pueden proporcionar un desafío que puede brindarte una gran experiencia en áreas como lectura de código, ingeniería inversa, pruebas, diseño de arquitectura de software, automatización y recopilación de requisitos, entre otras. + +--- + +[**A la página principal**](README.md) diff --git a/Spanish/PetProjects.md b/Spanish/PetProjects.md new file mode 100644 index 0000000..bec4893 --- /dev/null +++ b/Spanish/PetProjects.md @@ -0,0 +1,73 @@ +# :telescope: Proyectos personales + +Los proyectos personales (pet-projects) son una gran oportunidad para ganar experiencia práctica mientras se aprende un lenguaje de programación, bibliotecas y/o frameworks. También pueden servir como una plataforma de lanzamiento para entrevistas y ayudar a iniciar oportunidades de trabajo. + +Encontrar y seleccionar la idea correcta para un proyecto personal puede ser un desafío. Para ayudar a superar esto, hemos compilado una lista de enlaces e ideas para que comiences. ¡Después de leer esta lista, deberías poder elegir la idea más apropiada o inspirarte para crear la tuya propia! + +## :arrows_counterclockwise: Enlaces externos + +* [Google Summer of Code](https://summerofcode.withgoogle.com/archive) + +Una colección de proyectos es ofrecida por varias empresas y la comunidad como parte del programa anual de pasantías para estudiantes de Google. El archivo contiene proyectos de años recientes, con un número significativo de proyectos disponibles para el lenguaje C++. Puedes encontrar algo de interés para tu propia práctica o considerar intentar futuras pasantías. + +* [Project based learning - C++](https://github.com/practical-tutorials/project-based-learning#cc) + +El repositorio contiene una colección de proyectos personales para diferentes lenguajes de programación, incluyendo una extensa lista de ideas para C++. + +* [Programming challenges](https://web.archive.org/web/20250313115753/https://challenges.jeremyjaydan.com/) (copia archivada — el sitio original ya no existe) + +La Ruleta de Ideas para Proyectos Personales te permite establecer el nivel de complejidad deseado y girar la rueda. El resultado del giro determinará la tarea que deberás resolver, elegida al azar. :) + +## :boom: La lista de ideas de proyectos personales + +### :arrow_forward: Juegos + +A continuación hay una lista de videojuegos clásicos que no contienen IA compleja o generación de mundos dinámicos, que se pueden implementar como punto de partida. Puedes refinar la funcionalidad adicional a medida que progresas. Para la biblioteca de gráficos, puedes usar [SFML](https://www.sfml-dev.org/), que es una biblioteca fácil de usar que proporciona suficientes características para crear interfaces gráficas simples 2D o 2.5D usando [sprites](https://es.wikipedia.org/wiki/Sprite_(videojuegos)). Si quieres hacer algo más complejo con física aplicada, puedes comenzar con motores simples como [Box2D](https://box2d.org/) o aprender otros más avanzados como [Cocos2D](https://www.cocos.com/en/) y [Unreal Engine](https://www.unrealengine.com/en-US/). Recuerda seguir la regla de "lo simple a lo complejo" comenzando con un juego simple y aumentando gradualmente la dificultad. + +- [Snake](https://es.wikipedia.org/wiki/Snake_(videojuego)) +- [Tetris](https://es.wikipedia.org/wiki/Tetris) +- [El juego de la vida](https://es.wikipedia.org/wiki/Juego_de_la_vida) +- [Juego del 15](https://es.wikipedia.org/wiki/Juego_del_15) +- [Arkanoid](https://es.wikipedia.org/wiki/Arkanoid) +- [Buscaminas](https://es.wikipedia.org/wiki/Buscaminas) +- [2048](https://es.wikipedia.org/wiki/2048_(videojuego)) +- [Solitario](https://es.wikipedia.org/wiki/Solitario) +- [Solitario Spider](https://es.wikipedia.org/wiki/Solitario_Spider) +- [Ping-pong](https://es.wikipedia.org/wiki/Pong) +- [Donkey Kong](https://es.wikipedia.org/wiki/Donkey_Kong_(videojuego)) +- [Laberinto](https://es.wikipedia.org/wiki/Laberinto) +- [Juegos de red para 2-4 jugadores: ping-pong, póquer, ajedrez, batalla naval, etc.](https://es.wikipedia.org/wiki/Juego_en_l%C3%ADnea) + +Se recomienda leer las siguientes fuentes que contienen más información sobre varios algoritmos para el desarrollo de juegos. Pueden ser útiles para uno de los juegos mencionados anteriormente, o para tus propias ideas: +- https://www.redblobgames.com/ +- http://www.squidi.net/three/ + + +--- + +### :arrow_forward: Aplicaciones + +Al crear una aplicación, comienza con la implementación más simple, como una aplicación de consola. Después de cada paso completado, establece una tarea más compleja, como agregar una interfaz gráfica, hacer que la aplicación solicite datos de una fuente usando una solicitud HTTP, y luego escribir/leer los datos recibidos en un archivo/base de datos, etc. Siempre sigue el principio de "lo simple a lo complejo". + +Aquí hay algunos ejemplos de proyectos potenciales para principiantes: + +- Un chat de red (sockets crudos o usando [gRPC](https://grpc.io/docs/languages/cpp/quickstart)) +- Una calculadora +- Un administrador de archivos +- Un convertidor de moneda +- Recuperar una lista de "pull-requests" o "issues" de cualquier repositorio de Github +- Automatización de tareas rutinarias, como varios cálculos y generación de informes en forma de tablas. + +--- + +### :arrow_forward: Aplicaciones para estudiantes + +Los siguientes ejemplos son más adecuados para estudiantes que han tomado o tomado recientemente cursos básicos como álgebra lineal, geometría analítica, análisis matemático, física, etc. Las tareas que implican aplicar la teoría que han aprendido pueden ayudarles a lograr dos objetivos: consolidar sus conocimientos a través de la aplicación práctica, y practicar la programación. Este camino no está restringido a los demás, pero es más fácil para los estudiantes ya que su conocimiento de las disciplinas académicas aún está fresco. + +- Desarrollar una biblioteca de álgebra lineal, que implica trabajar con matrices, vectores y realizar cálculos +- Modelar varios procesos, como física y mecánica teórica +- Implementar métodos numéricos, incluyendo integración, diferenciación, aproximación e interpolación + +--- + +[**A la página principal**](../README.md) diff --git a/Spanish/README.md b/Spanish/README.md new file mode 100644 index 0000000..d1a3c45 --- /dev/null +++ b/Spanish/README.md @@ -0,0 +1,59 @@ +# Roadmap para Desarrolladores de C++ + +## :speech_balloon: Idiomas adicionales: [English](../README.md) [Русский](../Russian/README.md) [中文](../Chinese/README.md) + +C++ sigue siendo uno de los lenguajes de desarrollo más populares en [2025](https://survey.stackoverflow.co/2025/technology#most-popular-technologies). Hay bastantes personas que quieren empezar a aprender C++ y convertirse en desarrolladores. Se enfrentan a las preguntas: "¿Por dónde debería empezar? ¿Qué y en qué orden debería estudiar? ¿Qué libros debería leer?" + +Hemos intentado responder a estas preguntas a través del roadmap (hoja de ruta) presentado. El roadmap se centra en las competencias y habilidades generales que se encuentran comúnmente en la mayoría de los proyectos. Está diseñado para ayudar a aquellos que recién comienzan su educación o tienen una experiencia limitada. Puedes crear un plan de aprendizaje más efectivo sin distraerte con información irrelevante si estudias los materiales enumerados. Te ayudará a dominar C++ hasta el nivel comúnmente utilizado en muchos proyectos comerciales. + +Se recomienda que leas los artículos enumerados a continuación antes de comenzar a explorar el mapa. + + +# :bookmark_tabs: Artículos + +1. :flashlight: [¿Por qué se creó el roadmap y con qué propósito?](Rationale.md) +1. :mag: [¿Estás seguro de que requieres conocimientos de C++?](SelfIdentification.md) +1. :space_invader: [C++ - No es ciencia espacial](FunCpp.md) +1. :clipboard: [Áreas de aplicación de C++](AreasOfApplication.md) +1. :ghost: [Mitos y leyendas de C++](Mythbusters.md) +1. :robot: [El desarrollador de C++ y la inteligencia artificial](AI.md) +1. :chart_with_upwards_trend: [Clasificación de desarrolladores](Grades/Overview.md) +1. :mortar_board: [¿Cómo estudiar?](HowToStudy.md) +1. :books: [Libros y otros recursos sobre C++](Books/Overview.md) +1. :telescope: [Ideas para proyectos personales (Pet-projects)](PetProjects.md) +1. :triangular_ruler: [Conjunto de herramientas del lenguaje (Toolkit)](Tooling.md) +1. :package: [Bibliotecas y frameworks populares](Libraries.md) +1. :balance_scale: [Estándares de codificación y requisitos normativos](Compliance.md) +1. :gem: [Más recursos sobre C++: documentación, enlaces de la comunidad, etc.](CommunitySources.md) + + +# :milky_way: Roadmap + +El roadmap está disponible en los siguientes formatos: + +* :arrow_forward: [draw.io (vista interactiva)](https://salmer.github.io/CppDeveloperRoadmap/goto/drawio/?l=es) +* :arrow_forward: [SVG](https://salmer.github.io/CppDeveloperRoadmap/goto/svg/?l=es) + +El roadmap se **genera** a partir de una fuente de texto independiente del idioma ([`../tools/mapgen/`](../tools/mapgen/)) a un archivo `roadmap.drawio.svg` por idioma: la imagen que ves y un archivo [draw.io](https://www.drawio.com) en uno. Las instrucciones sobre cómo verlo y proponer cambios están [aquí](Graph/README.md). + +# :key: Licencia y condiciones +El roadmap se publica bajo la licencia **CC BY-NC-SA 4.0**: [RUS](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.ru) || [ENG](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.en). En resumen: + +- Solo puedes compartir, adaptar o copiar cualquier parte de los materiales presentados si proporcionas un enlace a las fuentes originales. +- Está **PROHIBIDO** usar cualquier parte de los materiales para fines comerciales. + + +# :mailbox: Comentarios y comunicación + +En caso de cualquier comentario, propuesta o idea, no dudes en contactarnos. Realmente valoramos tu apoyo. + +Puedes comunicarte con nosotros a través de uno de los siguientes canales vía Github: +- En caso de cualquier propuesta o modificación en el **contenido o el roadmap** - crea un nuevo PR en [Pull Requests](https://github.com/salmer/CppDeveloperRoadmap/pulls) (el roadmap se edita como cualquier otro archivo — ver [las instrucciones](Graph/README.md)) +- Para preguntas o sugerencias **sin un cambio concreto** - envía un nuevo Issue en [Issues](https://github.com/salmer/CppDeveloperRoadmap/issues) + + +# :telephone: Contactos + +Creadores: +- [Evgenii Melnikov](https://github.com/salmer), +- [Dmitrii Dmitriev](https://github.com/DmitrievDmitriyA), diff --git a/Spanish/Rationale.md b/Spanish/Rationale.md new file mode 100644 index 0000000..3692da2 --- /dev/null +++ b/Spanish/Rationale.md @@ -0,0 +1,15 @@ +# :flashlight: ¿Por qué se creó la hoja de ruta y con qué propósito? + +C++ se utiliza ampliamente en muchos proyectos comerciales y ha sufrido cambios significativos a lo largo de su historia, haciéndolo más conveniente para el uso diario. Sin embargo, todavía existen muchos mitos, especulaciones y miedos en torno al lenguaje que asustan a los estudiantes potenciales. Nuestro objetivo es ayudar a disipar estos mitos y facilitar a los principiantes el aprendizaje de C++. + +Actualmente hay una escasez de desarrolladores de C++ en el mercado. Nuestra experiencia muestra que muchos desarrolladores exitosos aprendieron el lenguaje de forma autodidacta, ya que era difícil encontrar información y recursos de calidad. La mayoría de las plataformas educativas y cursos no ofrecen lecciones de alta calidad, siendo muchos de ellos de nivel demasiado alto u obsoletos. + +La barrera de entrada al desarrollo en C++ es más alta en comparación con otros lenguajes, ya que la mayor parte de la información disponible está dirigida a desarrolladores experimentados, perpetuando aún más el mito de su excepcional complejidad. Hay una falta de información relevante para principiantes, lo que dificulta el aprendizaje del lenguaje. + +Esta hoja de ruta tiene como objetivo abordar estos desafíos. La idea de su creación surgió de realizar numerosas entrevistas con candidatos a desarrolladores de C++ sin experiencia, quienes compartían lagunas comunes en los conocimientos básicos y una falta de comprensión sobre cómo y dónde aprender el lenguaje. + +Esta hoja de ruta también puede ser útil para aquellos que ya han estado practicando C++ en proyectos personales y laborales. Puede ayudarte a identificar cualquier laguna en tus conocimientos y profundizar tu comprensión del lenguaje, permitiéndote convertirte en un especialista altamente calificado. + +--- + +[**A la página principal**](../README.md) diff --git a/Spanish/SelfIdentification.md b/Spanish/SelfIdentification.md new file mode 100644 index 0000000..45bee31 --- /dev/null +++ b/Spanish/SelfIdentification.md @@ -0,0 +1,20 @@ +# :mag: ¿Estás seguro de que necesitas conocimientos de C++? + +Lo primero que debes considerar es: ¿Por qué quieres aprender C++? + +El lenguaje tiene áreas de aplicación específicas, y es importante entenderlas antes de sumergirse en C++. Investiga y explora estas áreas para tener una mejor idea de en qué te estás metiendo. Aquí hay algunos ejemplos de por qué vale la pena investigar de antemano: + +- Algunas áreas de desarrollo pueden ser diferentes a lo que esperas. El desarrollo de videojuegos, por ejemplo, puede tener muchos desafíos, como el *crunch time* (horas extras excesivas), mala gestión y situaciones de trabajo por encargo. +- El lenguaje en el que estás interesado puede no ser el más popular en un área en particular. Por ejemplo, en el aprendizaje automático (machine learning), Python y sus bibliotecas especializadas son los más utilizados. + +# :question: Ya conozco C/C#/Java/Python, etc. ¿Puedo empezar a trabajar usando C++? + +Sí y no. :) + +Tener una comprensión básica de los conceptos de ciencias de la computación sin duda será útil, como entender la programación procedimental, la programación orientada a objetos (OOP) y otros conocimientos generales. Sin embargo, no debes depender únicamente de estos conceptos. El error más común cometido por los principiantes es intentar escribir C++ en los paradigmas de otros lenguajes. Por ejemplo, los desarrolladores de C a menudo escriben programas de C++ en un estilo procedimental o piensan que C++ es solo "C con clases". + +C++ es rico en ideas y enfoques de codificación, por lo que se recomienda comenzar a aprender el lenguaje con una mente abierta. Intenta entender sus ideas, ya que esto te ayudará a usar el lenguaje de manera efectiva en tus tareas de trabajo. El conocimiento de otros lenguajes puede ayudarte a compararlos e identificar sus fortalezas y debilidades. + +--- + +[**A la página principal**](../README.md) diff --git a/Spanish/Tooling.md b/Spanish/Tooling.md new file mode 100644 index 0000000..a3373ef --- /dev/null +++ b/Spanish/Tooling.md @@ -0,0 +1,369 @@ +# :triangular_ruler: Herramientas del lenguaje + +Los desarrolladores recién nacidos a menudo tienen una comprensión limitada de las herramientas disponibles para facilitar el trabajo con el código, aumentar la eficiencia y proteger contra muchos errores. Estas herramientas no son una bala de plata para las dificultades que pueda presentar el lenguaje, pero pueden suavizar significativamente las asperezas. A continuación se muestra una lista de herramientas comunes y populares reconocidas por desarrolladores de todo el mundo, pero es solo una pequeña parte de lo que está disponible. Con el tiempo, te familiarizarás más con estas herramientas y descubrirás otras nuevas que se adapten a tus necesidades. + +## :gear: Compiladores + +* :arrow_forward: **GCC (GNU Compiler Collection)** + + Sitio: https://gcc.gnu.org + + Precio: gratis + + El compilador predeterminado en la mayoría de las distribuciones de Linux y uno de los compiladores de C++ más utilizados en el mundo. Sigue de cerca los últimos estándares del lenguaje y produce código altamente optimizado. En Windows, está disponible a través de los proyectos MSYS2 y MinGW-w64. + +* :arrow_forward: **Clang** + + Sitio: https://clang.llvm.org + + Precio: gratis + + Un compilador construido sobre la infraestructura LLVM y el compilador predeterminado en macOS. Es conocido por su compilación rápida y mensajes de error claros y amigables para los humanos, lo que lo convierte en una buena opción para los principiantes. Clang también es la base de toda una familia de herramientas para desarrolladores, como clang-format, clang-tidy, y el servidor de lenguaje clangd utilizado por muchos editores. + +* :arrow_forward: **MSVC (Microsoft Visual C++)** + + Sitio: https://visualstudio.microsoft.com + + Precio: incluido en Visual Studio (la edición Community es gratis) + + El compilador de Microsoft, que se envía como parte de Visual Studio, y la opción principal para el desarrollo en Windows. La mayoría del software comercial y los proyectos de juegos para Windows se construyen con él. + + **Consejo:** Puedes probar rápidamente tu código en los tres compiladores uno al lado del otro sin instalar nada usando [Compiler Explorer](https://godbolt.org). + +## :page_facing_up: Editores de texto + +* :arrow_forward: **Visual Studio Code** + + Sitio: https://code.visualstudio.com/ + + Precio: gratis + + Un editor potente y eficiente para archivos de texto y código fuente está disponible. Tiene una rica biblioteca de extensiones que permite la personalización para las preferencias personales. También se puede configurar para trabajar con código fuente, permitiéndote compilar, ejecutar y depurar tu código con facilidad. Además, tiene un potente motor de búsqueda de archivos y carpetas, facilitando la búsqueda, lectura y el trabajo con grandes proyectos. + + +* :arrow_forward: **Notepad++** + + Sitio: https://notepad-plus-plus.org/ + + Precio: gratis + + Un editor ligero para archivos de texto y código fuente, es compatible con el resaltado de sintaxis para los lenguajes de programación comunes. En comparación con Visual Studio Code, es más conveniente para abrir y ver archivos rápidamente y debido a su diseño liviano, es cómodo trabajar con una gran cantidad de archivos de texto. + + +## :open_file_folder: IDE (Entorno de Desarrollo Integrado) + +* :arrow_forward: **Microsoft Visual Studio IDE** + + Sitio: https://visualstudio.microsoft.com + + Precio: la edición Community es gratis + + Un entorno de desarrollo integrado (IDE) de Microsoft, que proporciona un conjunto completo de herramientas que incluyen un editor de código, compilador, depurador y generador de perfiles (profiler), para varios lenguajes de programación y desarrollo multiplataforma. Una gran opción para principiantes, ya que su interfaz moderna es fácil de usar y requiere una personalización mínima de fábrica. + + +* :arrow_forward: **Qt Creator IDE** + + Sitio: https://www.qt.io/product/development-tools + + Precio: gratis para proyectos de código abierto (más detalles: [Qt Open Source](https://www.qt.io/download-open-source?hsCtaTracking=9f6a2170-a938-42df-a8e2-a9f0b1d6cdce%7C6cb0de4f-9bb5-4778-ab02-bfb62735f3e5)) + + Inicialmente, Qt Creator se posicionó como un IDE para desarrollar interfaces gráficas para aplicaciones en C++. Con el tiempo, el marco ha adquirido numerosas capacidades y se ha convertido en un ecosistema integral para el desarrollo multiplataforma. Ofrece una vasta biblioteca de primitivas para diversas necesidades como redes, interfaz gráfica, trabajo con bases de datos y el manejo de formatos populares como imágenes y archivos de texto. Hoy en día, Qt Creator sirve como un competidor de Visual Studio y es particularmente popular entre los desarrolladores que crean aplicaciones para diversas distribuciones de Linux. + + +* :arrow_forward: **Xcode** + + Sitio: https://developer.apple.com/xcode/ + + Precio: gratis + + El propio entorno de desarrollo de Apple y la única forma de crear aplicaciones para macOS e iOS. Viene con Clang y LLDB. Si trabajas en macOS, necesitarás Xcode al menos por sus herramientas de línea de comandos, incluso si prefieres escribir código en un editor diferente. + + +* :arrow_forward: **JetBrains CLion IDE** + + Sitio: https://www.jetbrains.com/clion + + Precio: gratis para uso no comercial (desde mayo de 2025); se requiere licencia paga para desarrollo comercial + + Potente IDE multiplataforma de JetBrains. Al igual que otros IDEs, proporciona un conjunto completo de herramientas para el desarrollo cómodo de software. Es conveniente para el desarrollo multiplataforma tanto en C como en C++. + +## :flashlight: Extensiones + +* :arrow_forward: **JetBrains ReSharper C++** + + Sitio: https://www.jetbrains.com/resharper-cpp + + Precio: gratis para estudiantes y profesores + + Una extensión para Microsoft Visual Studio, agrega funciones avanzadas para trabajar con el código fuente, como resaltado extendido de código y sugerencias, construcción de diagramas de dependencias entre proyectos, recomendaciones para corregir errores comunes en el código, información mejorada durante la depuración, búsqueda y navegación mejoradas dentro de proyectos, etc. Compite con Visual Assist. + +* :arrow_forward: **Visual Assist** + + Sitio: https://www.wholetomato.com + + Una extensión para Microsoft Visual Studio que proporciona funciones adicionales para trabajar con el código fuente, como resaltado de código mejorado y sugerencias, mayor información durante la depuración y codificación, capacidades de búsqueda avanzadas y navegación de proyectos mejorada. Compite con JetBrains ReSharper. + + +* :arrow_forward: **Incredibuild** + + Sitio: https://www.incredibuild.com + + Precio: hay que contactar al equipo de incredibuild para saber el precio + + Aplicación/extensión para la compilación distribuida de proyectos, que une todas las estaciones de trabajo de los desarrolladores en una sola red, brindando la posibilidad de usar decenas de máquinas para ensamblar y compilar el código fuente. Esto acelera el proceso de construcción de grandes proyectos. + +## :electric_plug: Gestores de paquetes y sistemas de compilación + +* :arrow_forward: **CMake** + + Sitio: https://cmake.org + + Precio: gratis + + Un sistema de automatización multiplataforma para compilar una aplicación desde el código fuente, que genera los artefactos necesarios para el posterior ensamblaje en la plataforma de destino. Actualmente se considera la herramienta estándar para compilar varias bibliotecas cuando se suministran como fuente. + +* :arrow_forward: **Conan** + + Sitio: https://conan.io + + Precio: gratis + + Un gestor de paquetes y dependencias para organizar bibliotecas y frameworks de C++. Soporta el trabajo en diversas plataformas como Windows y Linux, y tiene integración con herramientas como CMake y Visual Studio. + +* :arrow_forward: **vcpkg** + + Sitio: https://vcpkg.io + + Precio: gratis + + Un gestor de paquetes gratuito y de código abierto para bibliotecas C y C++, desarrollado por Microsoft. Proporciona miles de bibliotecas listas para usar y se integra perfectamente con CMake y Visual Studio. Junto con Conan, es uno de los dos gestores de dependencias más populares en el ecosistema de C++. + + +* :arrow_forward: **Ninja** + + Sitio: https://ninja-build.org + + Precio: gratis + + Gestor de compilación de proyectos para aplicaciones C y C++. La principal ventaja de este gestor es el ensamblaje rápido del proyecto. Soporta el desarrollo multiplataforma y funciona con todos los compiladores populares. + +* :arrow_forward: **ccache** + + Sitio: https://ccache.dev + + Precio: gratis + + Una caché de compilador: almacena los resultados de compilaciones anteriores y los reutiliza cuando vuelve a ocurrir la misma compilación, lo que puede acelerar drásticamente las reconstrucciones. Se sitúa de forma transparente frente a GCC o Clang y se integra con CMake en un par de líneas, convirtiéndolo en una de las victorias de tiempo de construcción más baratas en proyectos medianos y grandes. + + +## :mag: Analizadores de código y formateadores + +* :arrow_forward: **clang-format** + + Sitio: https://clang.llvm.org/docs/ClangFormat.html + + Precio: gratis + + El formateador de código automático estándar de facto para C++. Un único archivo de configuración (`.clang-format`) almacenado en el repositorio mantiene consistente el estilo de código de todo el equipo y elimina los debates de formato en la revisión de código. Está soportado por defecto en casi todos los editores e IDEs. + +* :arrow_forward: **clang-tidy** + + Sitio: https://clang.llvm.org/extra/clang-tidy/ + + Precio: gratis + + Una herramienta de análisis estático (linter) del proyecto LLVM. Comprueba el código frente a cientos de reglas — patrones propensos a errores, problemas de rendimiento, legibilidad, estilo C++ moderno — y puede corregir automáticamente muchos de los problemas que encuentra. Está integrado en la mayoría de los IDEs, incluyendo Visual Studio, CLion, VS Code, y Qt Creator. + +* :arrow_forward: **Sanitizers (ASan, UBSan, TSan)** + + Sitio: https://github.com/google/sanitizers + + Precio: gratis + + Herramientas de análisis dinámico integradas directamente en GCC, Clang y MSVC y habilitadas con banderas de compilador (p. ej., `-fsanitize=address`). AddressSanitizer detecta errores de memoria como el acceso fuera de los límites y el uso después de liberación (*use-after-free*), UndefinedBehaviorSanitizer detecta el comportamiento indefinido y ThreadSanitizer detecta las condiciones de carrera de datos. Ejecutar tus pruebas con sanitizadores habilitados se considera una práctica básica en el desarrollo moderno de C++. + +* :arrow_forward: **Fuzzing (libFuzzer, AFL++)** + + Sitio: https://llvm.org/docs/LibFuzzer.html, https://github.com/AFLplusplus/AFLplusplus + + Precio: gratis + + El fuzzing es la alimentación automática de un flujo de datos aleatorios y deliberadamente malformados en tu código en busca de cuelgues (crashes) y bloqueos. Es especialmente útil para todo aquello que analiza (*parsea*) entrada externa: analizadores de formatos, protocolos de red, decodificadores. Por lo general, se ejecuta junto con sanitizadores: el fuzzer encuentra la entrada que desencadena un error y el sanitizador muestra exactamente dónde ocurrió. libFuzzer está integrado en Clang; AFL++ funciona como una herramienta independiente. + +* :arrow_forward: **PVS Studio** + + Sitio: https://pvs-studio.com + + Precio: de pago; gratis para proyectos de código abierto y estudiantes + + Analizador de código estático multiplataforma (Windows, Linux, MacOS) por PVS-Studio. El objetivo principal del analizador es analizar el código fuente en busca de diversos errores que pueden pasar desapercibidos por los compiladores o durante la revisión del código. Ayuda a reducir el número de errores relacionados con la sintaxis del lenguaje y las trampas. + + +* :arrow_forward: **Cppcheck** + + Sitio: https://cppcheck.sourceforge.io + + Precio: gratis + + Un analizador de código gratuito que te ayuda a detectar errores comunes en tu código fuente que el compilador o la revisión de código podrían pasar por alto. Es multiplataforma y compatible con las distribuciones populares de Linux y Windows. + + +* :arrow_forward: **Valgrind** + + Sitio: https://valgrind.org + + Precio: gratis + + Un conjunto de herramientas que te pueden ayudar a investigar varios problemas mientras la aplicación se está ejecutando, como fugas de memoria y perfiles de rendimiento. Es compatible con múltiples distribuciones de Linux. En proyectos modernos, los sanitizadores cubren muchos de los mismos casos de uso con una sobrecarga mucho menor, pero Valgrind sigue siendo útil porque no requiere recompilación. + +## :beetle: Depuradores + +* :arrow_forward: **GDB (GNU Debugger)** + + Sitio: https://sourceware.org/gdb/ + + Precio: gratis + + El depurador estándar en el mundo GNU/Linux. Te permite establecer puntos de interrupción, avanzar paso a paso por el código, inspeccionar variables y memoria, y analizar volcados de memoria (core dumps) de aplicaciones colgadas. La mayoría de los front-ends de depuración de IDE en Linux (VS Code, Qt Creator, CLion) utilizan GDB bajo el capó, por lo que comprender sus conceptos básicos da sus frutos incluso si en su mayoría depuras desde un IDE. + +* :arrow_forward: **LLDB** + + Sitio: https://lldb.llvm.org + + Precio: gratis + + El depurador del proyecto LLVM y el depurador predeterminado en macOS (usado por Xcode). Ofrece capacidades similares a GDB con una arquitectura más moderna. + +* :arrow_forward: **WinDbg** + + Sitio: https://learn.microsoft.com/windows-hardware/drivers/debugger/ + + Precio: gratis + + El depurador de Microsoft para Windows. Para el trabajo diario en Windows, el depurador integrado en Visual Studio suele ser suficiente, pero WinDbg es indispensable cuando sus capacidades se quedan cortas: análisis de volcados de bloqueos (crash dumps) desde máquinas en producción, depuración de controladores y en modo kernel, trabajo con una aplicación sin código fuente. Una habilidad útil para cualquiera que desarrolle a bajo nivel o investigue bloqueos en las máquinas de los usuarios. + +## :stopwatch: Analizadores de rendimiento (Profilers) + +* :arrow_forward: **perf** + + Sitio: https://perfwiki.github.io/main/ + + Precio: gratis + + El perfilador de muestreo estándar en Linux, integrado en el kernel. Muestra dónde pasa realmente su tiempo de CPU una aplicación, con detalles de contadores de hardware (errores de caché, malas predicciones de bifurcación) cuando los necesitas. A menudo se utiliza junto con visualizaciones *flame-graph* (gráficos de llama) para hacer evidentes los cuellos de botella (hotspots). + +* :arrow_forward: **Tracy** + + Sitio: https://github.com/wolfpld/tracy + + Precio: gratis + + Un perfilador de cuadros (frames) en tiempo real que es especialmente popular en el desarrollo de juegos. Anotas zonas en tu código con macros ligeras y observas los tiempos en vivo en un cliente gráfico, hasta los marcos y subprocesos (threads) individuales. Multiplataforma y con una sobrecarga notablemente baja. + +* :arrow_forward: **Intel VTune Profiler** + + Sitio: https://www.intel.com/content/www/us/en/developer/tools/oneapi/vtune-profiler.html + + Precio: gratis + + Un perfilador potente para el análisis de rendimiento profundo en x86: puntos calientes (hotspots), eficiencia de subprocesos, patrones de acceso a la memoria y métricas a nivel de microarquitectura. La herramienta de referencia cuando el resultado de `perf` no es lo suficientemente detallado. En Windows, el IDE de Visual Studio también incluye un potente perfilador de CPU y memoria integrado. + +## :white_check_mark: Pruebas (Testing) y benchmarks + +* :arrow_forward: **GoogleTest (gtest/gmock)** + + Sitio: https://github.com/google/googletest + + Precio: gratis + + El framework de pruebas unitarias más utilizado en C++. Viene con GoogleMock para crear stubs y mocks, lo que te permite probar el código de forma aislada de sus dependencias — bases de datos, red, sistema de archivos. Se integra bien con CMake y se puede incluir mediante cualquiera de los gestores de paquetes populares. + +* :arrow_forward: **Catch2** + + Sitio: https://github.com/catchorg/Catch2 + + Precio: gratis + + Una alternativa más ligera a GoogleTest con una sintaxis concisa. Una prueba aquí es una función ordinaria con una macro `REQUIRE` en lugar de un conjunto de macros de comparación especiales. Una buena opción para proyectos pequeños y para familiarizarse con las pruebas unitarias: puede ser incluido como un único archivo de cabecera (header). + +* :arrow_forward: **Google Benchmark** + + Sitio: https://github.com/google/benchmark + + Precio: gratis + + Una biblioteca para microbenchmarks. Escoge la cantidad de repeticiones por sí misma para que el resultado sea estadísticamente significativo, y puede combatir la tendencia del optimizador de descartar código cuyo resultado nunca se usa. Es necesaria cuando tienes que comparar dos implementaciones por velocidad: medir el tiempo "a mano" con la lectura del reloj antes y después casi siempre da un resultado poco fiable. + +## :robot: Herramientas de IA + +Los asistentes de IA se han convertido en parte del conjunto de herramientas diario de un desarrollador: aceleran la escritura de código repetitivo (boilerplate), te ayudan a orientarte en una base de código desconocida y explican errores del compilador. Al mismo tiempo, no reemplazan el conocimiento del lenguaje — las razones se explican a continuación. + +* :arrow_forward: **GitHub Copilot** + + Sitio: https://github.com/features/copilot + + Precio: hay un nivel gratuito limitado; el acceso completo es de pago, y gratuito para estudiantes, profesores y mantenedores de proyectos populares de código abierto + + Autocompletado de código directamente en el editor: sugiere las siguientes líneas en función del contexto del archivo y el proyecto. Se integra con Visual Studio, VS Code, CLion, y otros IDEs populares. + +* :arrow_forward: **Claude Code** + + Sitio: https://claude.com/product/claude-code + + Precio: de pago, como parte de una suscripción + + Un asistente que trabaja en la terminal y en el IDE: lee todo el proyecto, realiza ediciones en varios archivos a la vez, y ejecuta la compilación y las pruebas. Está dirigido a tareas más grandes que una sola línea — refactorización, exploración de código desconocido, redacción de pruebas. + +* :arrow_forward: **Cursor** + + Sitio: https://cursor.com + + Precio: hay un nivel gratuito; las funciones avanzadas son de pago + + Un editor basado en VS Code con un asistente de IA incorporado. Puede responder preguntas sobre el código fuente y hacer ediciones en varios archivos a la vez, manteniendo las extensiones y configuraciones familiares de VS Code. + +* :arrow_forward: **Modelos locales (Ollama, llama.cpp)** + + Sitio: https://ollama.com, https://github.com/ggml-org/llama.cpp + + Precio: gratis + + Ejecutar modelos en tu propia máquina. Son inferiores en calidad a los modelos en la nube y requieren recursos notables, pero el código nunca sale de tu computadora. Esta es una opción para proyectos donde el envío de código fuente a servicios externos está prohibido. Por cierto, `llama.cpp` es en sí mismo un ejemplo instructivo de un proyecto moderno en C++. + +### :warning: Qué tener en cuenta + +- **Verifica todo lo que se genera.** Un modelo puede producir código plausible pero incorrecto: funciones de la biblioteca estándar que no existen, errores sutiles sobre el tiempo de vida de los objetos (object-lifetime bugs), condiciones de carrera. En C++ el costo de tal error es alto — el comportamiento indefinido puede no aparecer en ninguna prueba y puede explotar en la máquina de un usuario. Esta es exactamente la razón por la que el conocimiento del lenguaje sigue siendo obligatorio: para verificar una respuesta, necesitas comprender el tema no peor de lo que lo harías al escribir el código a mano. +- **Sigue la política de la empresa.** En muchas organizaciones, el envío de código de trabajo a servicios externos está restringido o prohibido. Aclara las reglas antes de conectar un asistente, no después. +- **Recuerda las licencias.** El código generado puede reproducir fragmentos de proyectos de otras personas junto con sus obligaciones de licencia. Para proyectos comerciales esto es un riesgo aparte que vale la pena discutir con tu equipo. +- **No te saltes la etapa de aprendizaje.** Un asistente te libera de la rutina, pero si resuelve por ti los mismos problemas de los que se supone que debes aprender, no crecerás como ingeniero. Al principio de tu carrera, es útil resolver un problema tú mismo primero y solo entonces compararlo con lo que sugiere el modelo. + +## :floppy_disk: Clientes de Git + +* :arrow_forward: **SmartGit** + + Sitio: https://www.syntevo.com/smartgit/ + + Precio: gratis para proyectos de código abierto + + Una herramienta completa y multiplataforma para trabajar con repositorios de Git. Viene con las siguientes características: recibir y enviar cambios al repositorio, ver el historial de cambios, un editor de texto para resolver conflictos, etc. Soporta la integración con todos los repositorios populares como GitHub, BitBucket, GitLab, etc. + +* :arrow_forward: **Atlassian SourceTree** + + Sitio: https://www.sourcetreeapp.com/ + + Precio: gratis + + Una gran alternativa gratuita para trabajar con Git usando una GUI (interfaz gráfica de usuario). Tiene la misma funcionalidad que SmartGit, con la excepción de que no cuenta con su propio editor para la resolución de conflictos. Sin embargo, esto puede ser arreglado fácilmente integrando Visual Studio Code o cualquier otro editor que pueda comparar archivos. Ten en cuenta que a diferencia de SmartGit, solo está disponible para Windows y macOS. Es compatible con la integración con repositorios populares como GitHub, BitBucket, GitLab, etc. + + +* :arrow_forward: **Git Kraken** + + Sitio: https://www.gitkraken.com/ + + Precio: gratis para proyectos de código abierto + + Un cliente multiplataforma y muy eficiente para Windows, Linux y MacOS. Admite la integración con GitHub, Bitbucket y Gitlab, y tiene todas las funciones necesarias para el trabajo diario, como ver el historial de cambios, enviar y recibir cambios, cambiar entre ramas y un editor de resolución de conflictos incorporado. + +--- + +[**A la página principal**](../README.md) diff --git a/TODO.md b/TODO.md deleted file mode 100644 index a0c381e..0000000 --- a/TODO.md +++ /dev/null @@ -1 +0,0 @@ -1. Добавить испанский diff --git a/_config.yml b/_config.yml index 4aec19d..1fde1c2 100644 --- a/_config.yml +++ b/_config.yml @@ -4,7 +4,7 @@ baseurl: /CppDeveloperRoadmap description: >- A roadmap for learning C++: what to study and in what order, book recommendations per level, developer grading, pet-project ideas, and tooling. - Available in English, Russian, and Chinese. + Available in English, Russian, Chinese, and Spanish. # Used theme: https://github.com/pages-themes/cayman remote_theme: pages-themes/cayman@v0.2.0 diff --git a/_layouts/goto.html b/_layouts/goto.html index f75a7bd..8e574da 100644 --- a/_layouts/goto.html +++ b/_layouts/goto.html @@ -15,6 +15,9 @@
  • English
  • Русский
  • 中文
    • + {%- if page.targets.es %} +
  • Español
    • + {%- endif %}