diff --git a/English/Graph/roadmap.html b/English/Graph/roadmap.html
index 9e5e324..cf5c49b 100644
--- a/English/Graph/roadmap.html
+++ b/English/Graph/roadmap.html
@@ -8,497 +8,9 @@
padding:2px
}
-
-
-
-C++ developer
-Soft skills
-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
-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
-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
-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
-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
-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
-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
-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
-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
-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
-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
-