augusmeow's Personal Site

C++11 was a major overhaul of the language, introducing modern C++ paradigms.

Core Language Features:

• Automatic Type Deduction: auto and decltype to avoid redundant type names.
• Move Semantics: Rvalue references, move constructors, and move assignment operators to minimize data copying.
• Smart Pointers: std::unique_ptr and std::shared_ptr for RAII-based resource management.
• Lambdas: Unnamed function objects for inline logic.
• Variadic Templates: Templates that handle an arbitrary number of arguments.
• Uniform Initialization: Use of brace initialization {} for all types.
• Concurrency: A formal memory model, std::thread, std::mutex, std::atomic, and std::future.
• Other essentials: nullptr, long long, scoped enums (enum class), constexpr, static_assert, and noexcept.

Standard Library Additions:

• Containers: std::unordered_map (hash tables), std::forward_list (singly-linked list), and std::array (fixed-size array).
• Utilities: std::tuple, type traits for metaprogramming, and regular expressions.

C++17 focused on refining the language and adding utility types to the standard library.

Language Features:

• Structured bindings: Simplifies unpacking tuples or structs.
• CTAD (Constructor Template Argument Deduction): Simplifies object definitions by deducing template arguments from constructor arguments.
• Fold expressions: Simplifies the use of variadic templates.
• Inline variables: Allows static variables to be defined in header-only libraries.
• Standard attributes: [[maybe_unused]], [[nodiscard]], and [[fallthrough]] to catch common mistakes.
• Constant expression if: Simplifies compile-time evaluated code.

Standard Library Additions:

• Vocabulary types: std::optional, std::variant, and std::any for expressing alternatives.
• std::string_view: A non-owning reference to an immutable sequence of characters.
• Filesystem library: Portable manipulation of file-system paths and directories.
• Parallel STL: Multi-threaded or vectorized versions of standard algorithms.
• Concurrency: std::shared_mutex, std::shared_lock, and std::scoped_lock.

Raft is a consensus algorithm designed for manageability and understandability, serving as an alternative to Paxos. It ensures that a cluster of machines can function as a single unit and tolerate the failure of some nodes. Raft decomposes the consensus problem into three independent sub-problems: Leader Election, Log Replication, and Safety.

Key characteristics include:

• Leader-Centric: A single leader is elected to handle all system decisions, and data flows only from the leader to other nodes.
• Fault Tolerance: The system remains available as long as a majority of nodes are operational (e.g., a 5-node cluster can tolerate 2 failures).
• Asynchronous Safety: It does not rely on timing or synchronized clocks to ensure log consistency, making it resilient to network delays and packet loss.
• Dynamic Membership: It supports adding or removing nodes from the cluster without interrupting service.