Modern C++ Features & Concurrency from Coursera

Updated in May 2025.

This course now features Coursera Coach!

A smarter way to learn with interactive, real-time conversations that help you test your knowledge, challenge assumptions, and deepen your understanding as you progress through the course.

This course delves into the latest features of Modern C++, with a primary focus on concurrency, C++17 language updates, and powerful tools that enhance code performance and reliability. You will explore the capabilities of C++17, including the introduction of advanced concurrency techniques, templates, and functional programming tools. This comprehensive guide equips you with the knowledge to build efficient, concurrent programs while utilizing the most current features of C++ for maximum performance.

The course starts with concurrency basics, introducing the importance of multi-threading and how to implement it using std::thread. You will dive deeper into thread synchronization with std::mutex and learn how to pass arguments to threads. You'll then explore task-based concurrency with std::async, std::future, and std::promise, and learn how to propagate exceptions between threads seamlessly. This will provide you with the tools needed to write scalable, thread-safe applications.

As you move into the C++17 core language features, you'll examine the new features, such as inline variables, noexcept, and structured bindings. C++17 also brought mandatory copy elision, and this course will clarify its benefits. You'll gain an understanding of how to leverage these new features to make your code more efficient and readable.

The final sections cover advanced template features like Compiled Time Argument Deduction (CTAD), if constexpr, and folding expressions, as well as C++17 standard library additions like std::optional, std::variant, and parallel algorithms. These components empower you to write more flexible, error-free, and high-performance C++ code.

What's inside

Syllabus

C++ Concurrency

In this module, we will dive into the core concepts of C++ concurrency, beginning with thread creation and synchronization. You’ll explore various thread management techniques and task-based concurrency, learning how to handle shared data, exceptions, and synchronization across multiple threads.

Career center

Learners who complete Modern C++ Features & Concurrency will develop knowledge and skills that may be useful to these careers:

High-Performance Computing Engineer

High Performance Computing Engineers are at the forefront of designing and optimizing software for maximum computational speed, crucial in scientific research, data analysis, and financial modeling. This involves crafting efficient algorithms and leveraging hardware capabilities. The Modern C++ Features & Concurrency course directly aligns with this by thoroughly exploring advanced concurrency techniques such as multi-threading with std::thread and std::mutex, and task-based concurrency using std::async, std::future, and std::promise. Learners will understand how to build scalable, thread-safe applications and propagate exceptions seamlessly, which is vital for robust HPC systems. Furthermore, the course's deep dive into C++17 language updates, advanced template features like Compiled Time Argument Deduction and folding expressions, alongside parallel algorithms from the C++17 standard library, empowers individuals to write high-performance C++ code that fully utilizes modern hardware, leading to significant advances in computational efficiency.

See salaries and explore the career path for High-Performance Computing Engineer

Game Engine Programmer

Game Engine Programmers are responsible for developing the core software framework that powers video games, focusing on rendering, physics, input, and networking. This highly demanding role requires expert-level C++ skills, meticulous performance optimization, and sophisticated concurrency management to deliver smooth, immersive experiences. The Modern C++ Features & Concurrency course directly addresses these critical requirements. It delves into advanced concurrency techniques, including multi-threading, thread synchronization with std::mutex, and task-based concurrency with std::async, std::future, and std::promise, which are essential for managing game logic, AI, and resource loading across multiple threads. The course's exploration of C++17 language features, advanced template programming (like if constexpr and folding expressions), and C++17 standard library components (such as parallel algorithms) provides the knowledge to build efficient, high-performance C++ code. This comprehensive guide helps elevate code performance and reliability, crucial for creating cutting-edge game engines.

See salaries and explore the career path for Game Engine Programmer

Systems Programmer

A Systems Programmer develops software that manages and controls computer hardware and provides essential services for other applications, often working on operating systems, compilers, or low-level utilities. This role demands a deep understanding of how software interacts with hardware for optimal performance. The Modern C++ Features & Concurrency course offers a robust foundation for this profession. It covers fundamental aspects of C++ concurrency, including thread creation, synchronization, and handling shared data, which are critical for robust system-level components. Exploration of C++17 core language features, such as inline variables and structured bindings, along with mandatory copy elision, helps build highly efficient and readable code. Moreover, the focus on C++17 standard library components and function wrappers equips future Systems Programmers with the tools to manage callable objects effectively and apply performance optimizations, preparing them to engineer efficient and reliable system software.

See salaries and explore the career path for Systems Programmer

Quantitative Developer

As a Quantitative Developer, you would build and optimize complex financial models, trading systems, and analytical tools, often requiring lightning-fast execution and real-time data processing. Precision and performance are paramount in this domain. The Modern C++ Features & Concurrency course is exceptionally well-suited for aspiring Quantitative Developers. It provides a comprehensive exploration of advanced concurrency techniques, including multi-threading with std::thread and std::mutex, and task-based concurrency using std::async, std::future, and std::promise, which are vital for handling high-frequency data and executing concurrent trades. The course's focus on C++17 language updates and advanced template features like Compiled Time Argument Deduction and folding expressions helps in crafting highly efficient, robust code for complex algorithms. Furthermore, the use of std::optional and std::variant from the C++17 standard library supports the development of error-free and flexible financial applications, key for maintaining data integrity and system reliability in a demanding environment.

See salaries and explore the career path for Quantitative Developer

Scientific Programmer

Scientific Programmers develop and implement computational models and algorithms to solve complex problems in various scientific and engineering disciplines, such as physics, biology, and climate science. Their work requires code that is both numerically accurate and computationally efficient, often processing vast datasets. The Modern C++ Features & Concurrency course is highly valuable for a Scientific Programmer. It provides a robust understanding of advanced concurrency techniques, including multi-threading with std::thread and std::mutex, and task-based concurrency with std::async, std::future, and std::promise. These are essential for parallelizing simulations and data analysis tasks to achieve significant speedups. The course's deep dive into C++17 language updates, advanced template features like if constexpr and folding expressions, along with parallel algorithms from the C++17 standard library, empowers individuals to write high-performance C++ code that effectively leverages modern computing resources. This ultimately leads to faster and more accurate scientific discoveries.

See salaries and explore the career path for Scientific Programmer

Embedded Software Engineer

Embedded Software Engineers design and implement software for specialized computer systems found in devices ranging from consumer electronics to industrial machinery. Their work demands highly optimized, efficient code within resource-constrained environments. The Modern C++ Features & Concurrency course is particularly relevant, providing a strong foundation for this field. It explores advanced concurrency techniques, including multi-threading with std::thread and std::mutex, which are crucial for managing real-time processes and hardware interactions in embedded systems. The course's emphasis on C++17 language updates, such as mandatory copy elision and streamlined syntax, directly contributes to writing compact and performant code, essential where memory and processing power are limited. Additionally, the coverage of function wrappers and performance optimizations, alongside std::optional and std::variant from the C++17 standard library, helps individuals create flexible, error-free applications that meet the stringent demands of embedded development.

See salaries and explore the career path for Embedded Software Engineer

Firmware Engineer

Firmware Engineers develop the specialized software that provides low-level control for hardware devices, often operating directly with microcontrollers and embedded systems. This role demands a deep understanding of hardware interaction, resource optimization, and precise timing. The Modern C++ Features & Concurrency course offers invaluable knowledge for a Firmware Engineer. It covers C++ concurrency basics, including std::thread for multi-threading and std::mutex for synchronization, which are fundamental for managing concurrent hardware operations and efficient resource utilization. The course's exploration of C++17 core language features, such as inline variables and mandatory copy elision, directly supports writing compact and high-performance code, a necessity in constrained firmware environments. Additionally, learning about function wrappers for managing callable objects and C++17 standard library components helps develop reliable, flexible, and optimized firmware solutions, ensuring devices operate effectively and reliably at the lowest level.

See salaries and explore the career path for Firmware Engineer

Network Programmer

Network Programmers design and implement software for high-performance communication systems, including servers, client applications, and network protocols. This role demands efficient handling of data transmission, low latency, and robust concurrency to manage numerous connections. The Modern C++ Features & Concurrency course provides crucial skills for a Network Programmer. It thoroughly explores C++ concurrency, covering std::thread for multi-threading, std::mutex for synchronization, and task-based concurrency with std::async and std::future. These techniques are vital for building scalable, thread-safe network services capable of processing large volumes of concurrent requests. The course's focus on C++17 features, including streamlined syntax and performance optimizations, enables the development of highly efficient C++ code. Additionally, the C++17 standard library components and function wrappers help in writing flexible and error-free network applications, ensuring reliable and high-speed data exchange in demanding network environments.

See salaries and explore the career path for Network Programmer

Database Systems Engineer

Database Systems Engineers design, develop, and optimize the core components of database management systems, ensuring high performance, data integrity, and concurrent access for numerous users. This role demands efficient low-level programming and sophisticated concurrency control. The Modern C++ Features & Concurrency course is highly relevant for a Database Systems Engineer. It offers a comprehensive dive into advanced concurrency techniques, including multi-threading with std::thread and std::mutex, and task-based concurrency with std::async, std::future, and std::promise. These are crucial for managing concurrent read/write operations and ensuring transaction integrity within a database. The course's focus on C++17 language updates, such as mandatory copy elision and advanced template features, helps in writing highly optimized and reliable C++ code for database internals. Furthermore, the exploration of std::optional and std::variant from the C++17 standard library aids in building flexible, error-resistant data handling components, vital for robust database systems.

See salaries and explore the career path for Database Systems Engineer

Backend Software Engineer

Backend Software Engineers focus on the server-side logic, databases, and APIs that power web and mobile applications, often prioritizing scalability, reliability, and performance. While many languages are used, C++ is chosen for high-performance, low-latency services. The Modern C++ Features & Concurrency course can be particularly helpful for Backend Software Engineers working on such demanding systems. It provides a comprehensive understanding of advanced concurrency techniques, including multi-threading with std::thread and std::mutex, and task-based concurrency with std::async, std::future, and std::promise, which are vital for handling numerous concurrent user requests. The course's coverage of C++17 language updates and performance-enhancing features enables the development of highly efficient and reliable C++ backends. Similarly, the use of function wrappers and C++17 standard library components like std::optional and std::variant helps build robust and maintainable server-side applications, optimizing performance for critical services.

See salaries and explore the career path for Backend Software Engineer

Operating System Developer

Operating System Developers work on the core software that manages computer hardware and software resources, creating the fundamental environment for all other applications. This highly specialized role often involves deep systems knowledge, C and C++ expertise, and meticulous handling of concurrency. The Modern C++ Features & Concurrency course can be very useful for an Operating System Developer. It delves into the core concepts of C++ concurrency, including thread creation, synchronization with std::mutex, and task-based concurrency, which are foundational for understanding and implementing operating system kernels and services. The course’s exploration of C++17 core language features, such as noexcept and structured bindings, along with mandatory copy elision, helps in writing efficient and reliable system-level code. This role typically requires an advanced degree, and the course’s focus on performance optimizations and function wrappers prepares individuals to contribute to the complex and demanding world of operating system development.

See salaries and explore the career path for Operating System Developer

Automotive Software Engineer

Automotive Software Engineers develop the critical software systems within vehicles, covering areas from engine control units and infotainment to advanced driver-assistance systems (ADAS) and autonomous driving. This field requires robust, real-time, and highly performant code. The Modern C++ Features & Concurrency course is particularly relevant for those pursuing a career as an Automotive Software Engineer. It offers a comprehensive understanding of advanced concurrency techniques, including multi-threading with std::thread and std::mutex, and task-based concurrency with std::async, essential for managing multiple vehicle functions simultaneously and ensuring real-time responsiveness. The course's deep dive into C++17 language updates and advanced template features helps in writing efficient, reliable, and maintainable C++ code. Furthermore, the exploration of parallel algorithms from the C++17 standard library allows for designing high-performance solutions, critical for complex automotive applications where safety and responsiveness are paramount.

See salaries and explore the career path for Automotive Software Engineer

Robotics Software Engineer

Robotics Software Engineers develop the intelligence and control systems for robots, involving real-time processing, sensor integration, motion planning, and complex decision-making. This demanding field relies heavily on efficient, concurrent, and robust software. The Modern C++ Features & Concurrency course offers highly relevant knowledge for a Robotics Software Engineer. It delves into advanced concurrency techniques such as multi-threading with std::thread and std::mutex, and task-based concurrency with std::async, which are essential for managing concurrent robot operations, sensor data processing, and actuator control. The course's exploration of C++17 core language features, including streamlined syntax and mandatory copy elision, helps in writing optimized and readable code, crucial for reliable robotic systems. Furthermore, the coverage of advanced template features and parallel algorithms from the C++17 standard library equips learners to build flexible, high-performance C++ code, enabling sophisticated robotic functionalities.

See salaries and explore the career path for Robotics Software Engineer

Audio Software Engineer

Audio Software Engineers develop applications for digital audio workstations, real-time audio processing, music synthesis, and effects. This specialization demands precise timing, low latency, and efficient computational power, often requiring careful management of concurrent audio streams. The Modern C++ Features & Concurrency course is highly relevant for an Audio Software Engineer. It deeply explores C++ concurrency, covering std::thread for multi-threading and std::mutex for synchronization. These techniques are essential for managing real-time audio components and avoiding glitches. Task-based concurrency with std::async and std::future may be useful for non-real-time audio tasks like file loading or background processing. The course’s emphasis on C++17 features, advanced template programming, and performance optimizations helps in crafting efficient, reliable C++ code. The C++17 standard library components and function wrappers can facilitate the creation of flexible audio architectures, ensuring high-fidelity and responsive audio applications.

See salaries and explore the career path for Audio Software Engineer

Compiler Engineer

Compiler Engineers design and implement the tools that translate source code into executable programs. This highly technical field requires an intricate understanding of programming language semantics, intermediate representations, and target machine architectures. While the Modern C++ Features & Concurrency course does not teach compiler design, it may be useful for a Compiler Engineer. A strong command of Modern C++ features, as covered in this course, is essential given that many compilers and development tools are written in C++. The course's detailed exploration of C++17 language updates, including streamlined syntax and advanced template features like Compiled Time Argument Deduction and folding expressions, provides insight into the language constructs that compilers must parse and optimize. Understanding function wrappers and performance optimizations can also be valuable when working on the C++ codebase of a compiler itself, helping to maintain and enhance these complex systems. This role often requires an advanced degree.

See salaries and explore the career path for Compiler Engineer