Running list of more terms/concepts we could document in glossary

Commencez par glossary.md et examinez la liste existante de concepts C++ et de ressources externes proposés. L’issue est davantage un compte rendu de brainstorming ouvert qu’une tâche de documentation définie ; sa réalisation nécessiterait de restreindre le périmètre et de convenir des termes ou liens à ajouter.

The glossary is developing quickly into a pretty solid resource for the key terms you'll encounter and need to know while learning C++ at Mapbox. Or when starting to teach colleagues about how we write, deploy, and approach C++ at Mapbox.

While the glossary says explicitly that It is not intended to be a complete reference on language or syntax terms, there is much more we can do. This is a ticket to brainstorm additional concepts, terms, and keywords that are potential things to cover in the glossary and related docs.

Most of these terms don't need to be defined in the glossary, rather it would be sufficient to simply list them and links to external resources (particularly style guides we support). The overall goal is 1) note they are important to understand for C++ development a mapbox (by their presence), and 2) provide a great resource to learn more about them. We can add extra definitions where our opinions matter.

(Will be editing this in place as I collect ideas)

Key learning concepts

• the idea of a main function in an executable
• how to pass arguments to a C++ program and parse them - refs #35
• const
• const char* vs std::string and how they relate
• pointers vs references
• dereferencing pointers
• taking the address of a variable
• header guards vs #pragma once
• learning the cpp preprocessor
• what are templates and when to use them
• global variables, why not to use them, when they are appropriate
• when to use static_cast, reinterpret_cast, and const_cast. Why to use them rather than c style cases
• how enumerations work enum in C++11. Using casts to change between them and integer types
• the max size of numeric types. using <limits> from the stdlib to know these sizes dynamically
• integer overflow. When it is undefined behavior, when it is defined. How to control it/prevent it. How it differs for signed types and unsigned types
• compiler warnings. how to avoid them, fix them, appropriately suppress them. Why, when starting projects, it makes sense to use -Werror and very aggressive warnings, even -Weverything
• how to use c++ exceptions: why to always make custom exceptions subclass std::exception. How to catch all types by catching std::exception. Why to catch exceptions by const&.
• when to avoid throwing exceptions due to performance concerns (e.g. in tight loops)
• what is garbage collection
• What is reference counting
• Why, when, and how to use std::unique_ptr vs std::shared_ptr
• zero copy
• Big takeaways of C++11 vs C++14 vs c++17
• move semantics / universal references
• considerations on when to use std::vector vs std::map vs std::list
• binary size, why it matters, how you can learn about it (https://github.com/google/bloaty)
• What is the _GLIBCXX_USE_CXX11_ABI flag on linux and why does it matter?

Advanced performance concepts

• Arena allocation vs Memory Pools vs Region-based memory management: https://natsys-lab.blogspot.com/2015/09/fast-memory-pool-allocators-boost-nginx.html
• Alternative allocators: https://howardhinnant.github.io/stack_alloc.html
• Profiling with BCC tools: https://github.com/iovisor/bcc