https://github.com/salmer/CppDeveloperRoadmap
C++ developer
https://github.com/salmer/CppDeveloperRoadmap/blob/main/README.md
Soft skills
https://github.com/salmer/CppDeveloperRoadmap/blob/main/README.md
Hard skills
At first, some of the skills may seem impossible to develop. However, we think differently. It is possible to work on each of the skills. Everything depends on your desire and internal blocks. Everything is individual, and it's up to you to decide. :)
Ability to learn
Manage mistakes
Thinking
Responsibility
Manage resources
Communication
Team work
Emotional intelligence
Understanding the development context
Customer focus
Technology
Trends
Empathy
Concentration
Open-mindedness
Adaptability
Stress resistance
Working in uncertainty
Understanding the distribution of roles in a team
Support team members
Work in a distributed team
Providing feedback
Leadership
Mentoring
Delegation
Assigning and clarifying tasks to employees
Planning and goal setting
Negotiation
English
Presentation
Written communication skill
Networking
Ability to listen
Persuasion
Ability to communicate ideas and thoughts within the team
Finding compromises
Dispute resolution
Providing information to people outside the team
Time management
Prioritization
Taking decisions
Blind typing
Multitasking
Discipline
Persistence
Initiative
Independence
Problem solving
Logical
Critical
Creative
Strategic
Systems
Accept criticism
Notify about mistakes in time
Admitting your mistakes
Analyze mistakes
Ask the right questions
Experimenting
Manage knowledge
Process information
Ability to gather, analyze, evaluate information and make decisions based on it.
Reflection
Calmly react to what people say. Most likely that they only consider their own context when they try to prove something. This is fine. Evaluate the usefulness of their point of view.
Take challenging tasks in order to develop your skills and competencies, even when there is not enough knowledge/experience (skills will develop much faster through such tasks). The main thing is to distinguish a really useful complex task that will help you to boost your skills from a dumb task that requires a scapegoat.
You should be responsible for your professional development. Don't wait for the team lead to decide for you what to study. Do not forget that blind adherence to someone else's plan will sharpen your skills according to requirements of a particular company. It is better to discuss and build in your interests into the plan. If this is not done, there is a high risk of getting irrelevant skills, which will hit career opportunities. But don't overdo it: don't study absolutely everything or don't passively wait until a development plan will be created for you.
Self-organization
The ability to provide the amount of information that is necessary to communicate to people with different backgrounds.
Conflict solving
If you read this it means you already understand why it is so important :)

Usually, it is required at least to read because you would need to understand technical documentation. But as you move up the career ladder, you will need to speak and write more confidently in English.
Look for like-minded people and join/create a community for experience exchange.
You should study and observe contemporary trends to be competitive, as well as being able to adapt to them.
Experienced developers should develop management skills and business communication skills to complete tasks efficiently. It is easier to do if you have developed emotional intelligence. For a junior developer, the skill is also useful to better interact with colleagues.
1 step
Folder 1
Basic operations
Arithmetic operations
Loops: for/while
Logical operations
Bitwise operations
Functions
lambda
Operators
Data types
Dynamic typing
Static typing
RTTI
Pointers & References
Codebase structuring
References
Memory model
Smart pointer
Raw pointers
Code splitting into headers/cpp files
Scope
Memory leakage
Forward declaration
unique_ptr
shared_ptr
Lifetime of objects
new/delete operators
weak_ptr
Namespaces
The overloading of regular set of operators for regular or custom types (structures/classes).
To prevent memory leakage problems it is better to use smart pointers rather than raw pointers.
2 step
Folder 2
Structures and classes
Exception handling
Overloading of functions
Virtual table (vtbl)
Object Oriented programming (OOP)
Exceptions
Access violation
Dynamic polymorphism
Virtual methods
The rule of zero/three/five
Static polymorphism
Multiple inheritance
Diamond inheritance
Error codes
It's preferred to avoid multiple inheritance (excepting abstract classes) to prevent runtime issues
3 step
Folder 3
auto (automatic type deduction)
Language concepts
type casting
static_cast
const_cast
dynamic_cast
reinterpret_cast
Undefined Behavior (UB)
Argument-dependent lookup (ADL)
Macros
Name mangling
Standard library
iostream
Algorithms
Iterators
Containers
Date/time
Multithreading
Some of language constructions have non-declared behavior according to the ISO standard. In case of any error, it's not possible to predict further behavior. It depends on a platform environment, runtime context, etc.
4 step
Folder 4
Templates
Variadic templates
The template specialization
type traits
SFINAE
The full template specialization
The partial template specialization
RAII
pimpl
Erase-Remove
Non-Copyable/Non-Moveable
Copy and swap
Copy on write
CRTP
Standards
C++11/14
C++17
C++20
newest
C++0x
Idioms
1 step
Folder 5
Working with source code
Text editors
IDE
Code editors
Debugger
Linters
Knowledge of features and abilities (shortcuts, tools, plugins)
Understanding of debugger messages
Debugging symbols
WinDbg
GDB
Choose one of the popular IDEs and study it well: Eclipse, MS Visual Studio, Qt Creator, JetBrains Clion, XCode, etc.
Study how to use a debugger and all its features
Choose one of the popular editors and study it well. For example: Notepad++, Atom, etc.
The ability to work with a debugger via command line is a not common skill. It's sufficient to work with it via IDE. For example: set conditional breakpoints, etc.
Learn about common errors (segfault, out of memory, access violation) and undefined behavior concept.
Choose one of the popular editors and study it well. For example: Visual Code, Atom, Sublime Text, etc.
3 step
Folder 6
Compilers
Basic understanding of compilers stages
Compilation of sources to object files (compilation)
The object files linkage (linking)
Working stages of compilers
Platform dependent compilers
Each platform-dependent compiler has its nuances. It's good to know about them to prevent getting any trap: Clang++/LLVM, Intel C++, MSVS C++, GCC, MinGW
The compiler performs several stages of code compilation. It's good to know about all of them to better understand compilation issues. Deep knowledge is needed for compiler creators only.
5 step
Folder 7
Build systems
CMake
Makefile
ninja
Package managers
vcpkg
spack
Conan
nuget
Libraries
boost
opencv
poco
Libraries inclusion
protobuf
gRPC
fmt
pybindll
spdlog
ranges_v3
tensorflow
opencl
Frameworks
gtest/gmock
Qt
catch2
google profiler
pytorch c++
1 step
Folder 8
Computers Science
Data structures
Algorithms
Boolean algebra
Finite-state machines
It's also good to know how to calculate algorithm complexity and memory consumption.
4 step
Folder 9
Version control software
Distributed
Centralized
SVN
git
Mercurial
Best practices
Code quality
Code guidelines
Principles of development
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
Skill to read existing code sources
Skill to review code
Lifecycle stages of a software
Implementation
Testing
Maintanance
Versioning
Unit tests
Integration tests
Functional tests
Performance tests
Software architecture and components design
Components integration
Deployment
Collecting requirements
End of a software lifecycle
Code analyzers
Static analyzers
Dynamic analyzers
Profilers
C++ core guidelines
Industrial standards
MISRA
Autosar
Command line
batch
Powershell
bash
CI/CD
Trunk Based Development
Zero downtime deployment
Creation of a software deployment package
Documentation
Installer package
Usage of other programming languages
Language interoperability
Naming conventions, tabs vs spaces, etc.
To configure automated code formatting verification with one of the suitable utilities: clang-format, Resharper - code style, MSVS - code style.
- Scripting - Functional - SQL like - NoSQL
Sometimes it's needed to provide an ability to reuse a library written in a different language from another one. For example: to call C++ libraries in C#.
Backward compatibility
Software design
Architecture styles
Component-based
Monolithic application
Layered
Client-server
Microservices architecture
Event-driven
Plug-ins
REST
Service-oriented architecture
2 step
Folder 10
Design Patters (GoF)
Behavioral
Structural
Creational
OOP
SOLID
UML
Architecture patterns
MVC
MVVM
Three-tier
Onion
Hexagon
Methodologies of development
Test Driven Development
Behavior Driven Development
Domain Driven Design
Memory
Memory abstractions
Memory alignment
Memory management
Binary units
Executable file
Static library
Dynamic library
Stack
Global memory
Heap
Application memory
Virtual memory
Operating systems
Multithreading
Errors
Dead lock
Race condition
Live lock
Starvation
Threads
Concurrency
Mutexes
Semaphores
lock-free
Event handling
Sync
Async
Process
Interprocess communication
Shared memory
Pipes
Serialization
json
XML
Network
TCP/IP
OSI
Sockets
HTTP
TCP
UDP
File system
Task scheduler
Virtualization
VirtualBox
VMware Workstation
Containers
Hyper-V
Docker
Cloud Services
Kubernetes
Security
Encryption
MultiCPU systems
Multicore CPU
NUMA
Input/output
Drivers
Audio
Graphics
Printers (printing)
DirectSound
OpenAL
DirectX
Vulkan
OpenGL
CUDA
Common skills
Language tools
Language syntax
C++ Developer Roadmap
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.
How to use:
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
Feedback:
Optional
Junior
Middle
Senior
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.
The senior developer has the skills to create a design and make decisions for a solution/component taking into account business area context.
The junior must acquire the following skill as soon as possible: to write easy-readable and well-structured code.
The juniors should be aware of middle/senior skills. It's enough to have a basic understanding of them.
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.
Repository:
https://github.com/salmer/CppDeveloperRoadmap
https://github.com/salmer/CppDeveloperRoadmap