## Course Objectives - Understand and master core C++ concepts along with the latest C++20/23 features. - Write efficient, maintainable, and scalable C++ code using best practices. - Learn advanced object-oriented programming (OOP), templates, and metaprogramming in C++. - Gain hands-on experience with multithreading, memory management, and performance optimization. - Work with popular C++ libraries and understand modern tooling for debugging, testing, and version control. ## Weekly Breakdown ### Week 1: Introduction to C++ and Environment Setup #### Topics: - [**Overview of C++: History, evolution, and use cases.**](https://spinncode.com/designs/iRm4PFfO): Discover the history and evolution of C++ programming language, its applications in various fields, and the importance of learning C++ for career opportunities and high-performance software development. Learn about the different revisions of C++ and explore its use cases in game development, financial applications, and more. Understand why C++ is a valuable skill for any aspiring software developer, from its versatility to its performance benefits. - [**Setting up a development environment (IDE: Visual Studio, CLion, or VSCode).**](https://spinncode.com/designs/Tm7LPhMN): Set up an efficient C++ development environment with step-by-step guides for Visual Studio, CLion, and VSCode. Learn about the importance of using an Integrated Development Environment and configure your toolchain, build system, and code style for optimized coding. Master your chosen IDE to boost productivity. - [**Compiling, linking, and running C++ programs.**](https://spinncode.com/designs/6FGBI6f1): Mastering the fundamentals of C++ programming starts with understanding how to compile, link, and run C++ programs. This process involves translating C++ source code into machine code using a compiler, fixing syntax errors, and generating object files. Learn how to set up your development environment and use popular compilers to get started with C++. - [**Basic syntax: Variables, data types, operators, and control structures.**](https://spinncode.com/designs/i4yFO2XW): Master C++ fundamentals with this in-depth guide, covering essential syntax elements including variables, data types, operators, and control structures to lay a solid foundation for efficient programming. Understand the basics of declaring and using variables in C++, and learn how to apply these concepts in real-world scenarios. By mastering the fundamentals of C++, you'll be well on your way to writing effective and efficient programs. #### Lab: - [**Install and set up a C++ IDE, write and compile your first C++ program.**](https://spinncode.com/designs/26rwXYOt) #### Lab Summary: Learn how to set up a C++ development environment, write and compile your first C++ program, and gain a solid understanding of the basics of C++ programming. This hands-on guide covers the installation of popular C++ IDEs like Visual Studio, CLion, and VSCode. Get started with C++ programming and move on to more advanced topics with confidence. ### Week 2: Data Structures and Algorithms in C++ #### Topics: - [**Built-in data types and structures (arrays, strings, pointers).**](https://spinncode.com/designs/HyPlWnbx): Mastering Arrays in C++. Learn how to declare, initialize, and access arrays in C++, understanding key concepts including data types, syntax, and memory locations to improve your programming skills. This topic provides a comprehensive overview of arrays, crucial for effective C++ programming. - [**STL containers: `std::vector`, `std::array`, `std::list`, and `std::map`.**](https://spinncode.com/designs/Sr9mhFUd): Discover the key features and uses of four essential STL containers in C++, including `std::vector`, `std::array`, `std::list`, and `std::map`, and learn through examples to effectively apply them in your programming projects. Master dynamic sizing, random access, and efficient data storage, with a focus on best practices. Explore the syntax and capabilities of each container to improve your C++ skills. - [**STL algorithms: Sorting, searching, and manipulating containers.**](https://spinncode.com/designs/07wVf8PJ): Learn to harness the power of STL algorithms in C++ to efficiently manipulate and transform data in containers, with best practices and code examples for non-mutating and mutating algorithms. Master techniques for sorting, searching, and iterating over elements, and discover additional resources for further learning. - [**Introduction to C++20 ranges and views for modern iteration.**](https://spinncode.com/designs/c7t033aI): Mastering C++20 ranges and views for efficient iteration, this topic introduces the basics of ranges and views, and demonstrates how to use them to simplify code and write idiomatic C++. Learn how to utilize views for transforming or projecting ranges without modifying underlying data and explore the range-based for loop for iterating over sequences. #### Lab: - [**Solve real-world problems using STL containers and algorithms.**](https://spinncode.com/designs/aAe5OAq1) #### Lab Summary: Master the use of STL containers and algorithms to solve real-world problems in C++. Learn how to apply data structures and algorithms to efficiently solve complex issues, and gain practical experience in using them through hands-on exercises. By the end, you'll be able to analyze problems and identify the most suitable STL containers and algorithms to use. ### Week 3: Functions and Modular Programming #### Topics: - [**Defining and calling functions: Return types, parameters, and overloading.**](https://spinncode.com/designs/UHaYxWWQ): Mastering C++ fundamentals, explore built-in data types and structures including arrays, strings, and pointers to write efficient code. Learn how to declare, initialize, and access arrays in C++ to store and manipulate multiple values of the same data type. Understand the basics of arrays to build a solid foundation in C++ programming. - [**Pass-by-value vs pass-by-reference, and `const` correctness.**](https://spinncode.com/designs/S0SfJPu4): Mastering function arguments in C++ is crucial for optimizing code performance, safety, and maintainability. The two primary methods for passing function arguments are pass-by-value and pass-by-reference, each with its pros and cons. Understanding `const` correctness is equally important for ensuring that our code is both safe and efficient. - [**Lambda expressions in modern C++.**](https://spinncode.com/designs/26HfQ97T): Master the fundamentals of lambda expressions in modern C++, including their syntax and capture clauses, to create concise and effective one-time use functions in your C++ programming projects. Learn how to define and use lambda expressions to simplify your code and improve readability. - [**Understanding inline functions and the `constexpr` keyword.**](https://spinncode.com/designs/saywQGAr): Mastering C++ functions with ease. Using `inline` functions effectively improves performance by reducing function call overhead, and enables code optimization. To maximize benefits, only inline small, simple functions and use them judiciously to avoid code duplication and potential performance degradation. #### Lab: - [**Write modular code using functions, with an emphasis on lambda expressions and constexpr.**](https://spinncode.com/designs/m6uXrXTC) #### Lab Summary: Learn how to write modular code using functions in C++, including defining and using functions effectively, lambda expressions, and constexpr for modern and efficient code. Develop skills to break down large codebases into manageable pieces, easing testing and maintenance. Master best practices for creating well-structured, readable, and maintainable code. ### Week 4: Object-Oriented Programming (OOP) in C++ #### Topics: - [**Understanding classes and objects in C++.**](https://spinncode.com/designs/Bgg4InX2): Discover the fundamentals of functions in C++ Object-Oriented Programming, including return types, parameters, and overloading, and learn how to define and call functions effectively in your C++ code. Explore the basic syntax and common return types, such as int, float, and void. Master the art of organizing and reusing code with functions to write cleaner and more maintainable C++ programs. - [**Constructors, destructors, and copy constructors.**](https://spinncode.com/designs/X2Fe76aL): Master the fundamentals of object-oriented programming in C++ with a deep dive into constructors, destructors, and copy constructors, including default constructors, template usage, and best practices for efficient resource management. Learn how to properly initialize and manipulate objects, and explore the role of move constructors and move assignment operators in optimizing resource transfer between objects. - [**Inheritance, polymorphism, virtual functions, and abstract classes.**](https://spinncode.com/designs/TbKgy6O6): Mastering object-oriented programming concepts in C++ is crucial for effective and efficient code development. This article delves into key OOP concepts, including inheritance, polymorphism, and virtual functions, providing a comprehensive understanding of C++ best practices. By exploring single inheritance, abstract classes, and other advanced techniques, developers can improve their C++ skills. - [**The Rule of Three/Five/Zero and smart pointers (`std::unique_ptr`, `std::shared_ptr`).**](https://spinncode.com/designs/87KRcFlK): Master modern C++ programming with the Rule of Three/Five/Zero and smart pointers. Learn to write efficient and safe code by understanding when to declare special member functions and how to effectively manage dynamic memory with `std::unique_ptr` and `std::shared_ptr`. This concept is essential for modern C++ programming best practices. #### Lab: - [**Design a class-based system implementing inheritance and smart pointers.**](https://spinncode.com/designs/NX9L00DQ) #### Lab Summary: Master the fundamentals of object-oriented programming in C++ by designing class-based systems that implement inheritance and utilize smart pointers for efficient memory management. Learn best practices and advanced techniques for creating modular, reusable code through step-by-step examples, including a simple banking system. Explore key concepts such as single responsibility, open/closed principle, and Liskov substitution principle to enhance your C++ programming skills. ### Week 5: Templates and Generic Programming #### Topics: - [**Understanding templates: Function and class templates.**](https://spinncode.com/designs/gi7CWSm3): Modern C++ programming relies heavily on templates and generic programming to create flexible code. Templates eliminate the need for duplicated code or explicit type casting, allowing developers to create efficient software systems. By mastering function and class templates, programmers can define reusable functions and classes that can work with various data types, streamlining their development process. - [**Template specialization and overloading.**](https://spinncode.com/designs/Bp4JfmEZ): Master the art of customizing C++ templates with specialization and overloading, and learn how to provide unique implementations for specific types while inheriting common functionality. Understand the syntax and best practices for using these advanced techniques effectively, and discover how to specialize templates for standard types like integers. - [**Variadic templates and fold expressions in C++17/20.**](https://spinncode.com/designs/Cc8jIvlH): Mastering variadic templates and fold expressions in C++17/20, discover the key features that enable the creation of expressive, flexible, and concise generic code. Variadic templates allow for defining templates with a variable number of arguments, making them a powerful tool in modern C++ programming. By utilizing parameter packs and forwarding packs, developers can write efficient and reusable code. - [**Concepts in C++20: Constraining templates with concepts.**](https://spinncode.com/designs/Lm8s1080): Discover the power of Concepts in C++20, a feature that allows you to constrain templates to specific types, making your code more expressive, safer, and easier to use. Learn how to define and use Concepts to restrict template parameters to satisfy specific conditions and explore their applications through practical examples. Master the fundamentals of Concepts and take your C++ skills to the next level. #### Lab: - [**Implement a generic data structure using templates and C++20 concepts.**](https://spinncode.com/designs/bQHCqHWk) #### Lab Summary: Implementing a generic data structure using C++ templates and C++20 concepts is crucial in mastering modern C++. The goal is to create reusable code that supports elements of any type while ensuring type safety and efficiency. By understanding template implementation and constraints, you'll learn to create a stack data structure using templates, implement stack operations, and utilize `std::string` and `int` as example types. ### Week 6: Memory Management and Resource Management #### Topics: - [**Understanding dynamic memory allocation (`new`, `delete`, `malloc`, `free`).**](https://spinncode.com/designs/jUXifu4j): Mastering dynamic memory allocation in C++ is crucial, and this topic covers the basics of `new`, `delete`, `malloc`, and `free`. Learn the key differences between these operators, including typed pointers, exception handling, and constructor calls. Discover best practices for memory management, including using `new` and `delete` and checking for failed allocation. - [**RAII (Resource Acquisition Is Initialization) and smart pointers for resource management.**](https://spinncode.com/designs/JZZInnjG): Mastering modern C++ techniques involves efficient memory management and resource handling. This topic discusses RAII (Resource Acquisition Is Initialization), a programming idiom that ties a resource's life cycle to an object's life cycle, ensuring proper cleanup. Key concepts include smart pointers like `std::unique_ptr`, `std::shared_ptr`, and `std::weak_ptr`, which simplify memory management and prevent common errors. - [**Memory leaks, dangling pointers, and best practices for avoiding them.**](https://spinncode.com/designs/Y5GTfi38): Learn how to avoid common C++ memory management issues like memory leaks and dangling pointers, discover best practices for preventing them, and explore tools for detecting and fixing memory leaks in your code. Understand the causes and consequences of memory leaks and dangling pointers, including performance degradation and security vulnerabilities. Master efficient memory management techniques to improve your C++ programming skills. - [**Modern memory management techniques using `std::unique_ptr`, `std::shared_ptr`, and `std::weak_ptr`.**](https://spinncode.com/designs/31IkZLYC): Master modern C++ programming with best practices and techniques, focusing on smart pointer classes to manage memory allocation. Learn how to prevent common memory issues using `std::uniqueptr`, `std::sharedptr`, and `std::weak_ptr`. Explore the benefits and usage of these smart pointers to improve your C++ programming skills. #### Lab: - [**Write a C++ program managing dynamic memory efficiently using RAII and smart pointers.**](https://spinncode.com/designs/CzbZSSs8) #### Lab Summary: Mastering dynamic memory management in C++ is crucial for avoiding memory leaks and dangling pointers. RAII and smart pointers are essential tools in modern C++, enabling efficient and safe memory management. By using smart pointers such as `std::unique_ptr`, `std::shared_ptr`, and `std::weak_ptr`, C++ programmers can effectively manage dynamic memory and improve code quality. ### Week 7: Multithreading and Concurrency #### Topics: - [**Introduction to multithreading in C++ with the `<thread>` library.**](https://spinncode.com/designs/9iYjCxAQ): Master the fundamentals of multithreading in C++ with the `` library. Learn how to create and manage threads efficiently, improving responsiveness and system performance. Discover how to leverage the `std::thread` class to execute multiple tasks concurrently and write modern, high-performance C++ code. - [**Synchronization primitives: Mutexes, condition variables, and locks.**](https://spinncode.com/designs/io1oQISg): Master the basics of multithreading in C++ with synchronization primitives like mutexes, condition variables, and locks. Learn how to safely access shared resources and prevent data corruption in concurrent programs. Discover how mutexes and locks are used to ensure exclusive access to shared variables. - [**Understanding deadlocks, race conditions, and strategies to avoid them.**](https://spinncode.com/designs/NXMDcJSt): Learn how to write efficient and concurrent C++ programs by mastering multithreading and avoiding common pitfalls like deadlocks and race conditions. Understand the consequences of these issues and discover strategies to prevent them, including practical examples in C++. Develop the skills to create reliable and secure multithreaded applications. - [**Futures, promises, and asynchronous programming in C++17/20.**](https://spinncode.com/designs/elj7Wizc): Master the art of asynchronous programming in C++17/20 by learning about futures, promises, and how to write efficient concurrent programs with the `std::future` class and `std::async` function. Understand how to represent the result of asynchronous operations and launch tasks asynchronously to improve performance. #### Lab: - [**Implement a multithreaded program using mutexes and condition variables, and solve concurrency issues.**](https://spinncode.com/designs/k47Cex8i) #### Lab Summary: Master the art of multithreaded programming in C++ by implementing a bank account system that simulates multiple threads depositing and withdrawing money concurrently. Learn how to use mutexes to protect shared data and condition variables to signal threads when data has changed. By solving concurrency issues, improve your skills in creating efficient and safe multithreaded programs. ### Week 8: File I/O and Serialization #### Topics: - [**File input/output in C++: Working with file streams (`std::ifstream`, `std::ofstream`).**](https://spinncode.com/designs/ese5AF0Z): Mastering file I/O in C++ involves utilizing `std::ifstream` and `std::ofstream` for reading and writing data to files. These file streams enable developers to handle file input/output operations efficiently, with `std::ifstream` used for reading and `std::ofstream` for writing. By understanding how to work with these streams, programmers can effectively manage file operations in their C++ applications. - [**Reading and writing binary data to files.**](https://spinncode.com/designs/xV3M4GHt): Mastering binary data in C++ requires understanding binary streams and how to use them to read and write binary data to files. C++ provides two types of binary streams, `std::ifstream` and `std::ofstream`, which can be used with the `std::ios::binary` flag to work with binary data. By using binary streams, developers can store or retrieve binary data, such as images, audio, or video files, in C++. - [**Text and binary serialization techniques.**](https://spinncode.com/designs/LNREF3b3): Master the art of converting object states into formats that can be stored or transmitted with C++ serialization techniques. Learn the pros and cons of text and binary serialization approaches, and gain hands-on experience with examples using the jsoncpp library. Understand how to implement text serialization in your own projects and improve your C++ skills. - [**Using third-party libraries for serialization (e.g., Boost.Serialization).**](https://spinncode.com/designs/vnovQuWU): Mastering C++ file I/O and serialization with ease using Boost.Serialization. Learn how to efficiently store and retrieve complex data structures and objects using a widely-used, open-source library. Simplify your serialization process with a flexible and efficient approach that supports text, binary, and XML formats. #### Lab: - [**Write a C++ program that reads from and writes to files, using both text and binary formats.**](https://spinncode.com/designs/5UWqUe5T) #### Lab Summary: Learn how to write a C++ program that reads from and writes to files in both text and binary formats using the `std::fstream` class. Understand the differences between text and binary files, and how to use C++ to perform file input/output operations. Master C++ programming with best practices and advanced techniques in file I/O and serialization. ### Week 9: Error Handling and Exceptions #### Topics: - [**Introduction to exception handling: `try`, `catch`, `throw`.**](https://spinncode.com/designs/CpOeb76l): Learn how to write robust and reliable C++ code using exception handling with the `try`, `catch`, and `throw` keywords, and discover how this mechanism manages runtime errors and unexpected events. Explore the basics of exception handling, including what constitutes an exception and how the throw-catch mechanism works. Mastering exception handling is crucial for developing efficient and error-free C++ programs. - [**Best practices for writing exception-safe code.**](https://spinncode.com/designs/ti14mLbE): Learn how to write exception-safe code in C++ by mastering techniques such as resource management with RAII and smart pointers, writing no-throw functions, and error handling with try-catch blocks. Discover best practices for ensuring your programs remain in a consistent state, even in the presence of exceptions, and learn how to use standard library exceptions effectively. - [**Modern alternatives: `std::optional`, `std::variant`, and `std::expected` in C++17/20.**](https://spinncode.com/designs/6zqaknFE): Master C++ programming with modern error handling and exceptions. Learn how to use `std::optional`, `std::variant`, and `std::expected` in C++17 and 20 to simplify error handling and improve code safety. Discover the benefits of these modern alternatives over traditional error handling methods. - [**Handling resources in exception handling: RAII revisited.**](https://spinncode.com/designs/QViaJQ7z): Mastering error handling and exceptions in C++ is crucial for writing safe and efficient code. The RAII (Resource Acquisition Is Initialization) concept ensures that resources such as memory, files, and locks are properly acquired and released, even in the presence of exceptions. By using RAII objects and smart pointers, you can minimize the risk of resource leaks and memory corruption. #### Lab: - [**Develop a C++ program that gracefully handles errors and exceptions.**](https://spinncode.com/designs/6XliSjU3) #### Lab Summary: Develop a C++ program that handles errors and exceptions gracefully, using best practices for exception-safe code and built-in exception handling mechanisms. Learn about types of exceptions in C++, including synchronous and asynchronous exceptions, and understand how to use try-catch blocks and custom exception types to manage errors. Master the fundamentals of exception handling in C++ to write robust and reliable code. ### Week 10: Testing, Debugging, and Profiling #### Topics: - [**Unit testing in C++: Introduction to testing frameworks (Google Test, Catch2).**](https://spinncode.com/designs/BFb65x43): Mastering unit testing in C++ is crucial for ensuring code quality and reducing debugging time. This guide introduces two popular testing frameworks, Google Test and Catch2, showcasing their features and providing examples to get started. By exploring these frameworks, C++ developers can improve their code quality and development speed. - [**Mocking and test-driven development (TDD).**](https://spinncode.com/designs/qFgJUQ9Y): Mastering C++ testing and development with mocking and TDD best practices. Learn how to isolate dependencies and improve code efficiency using mocking frameworks like Google Mock. Discover how test-driven development can drive your coding process, ensuring testable, maintainable, and efficient code. - [**Debugging tools: GDB, Valgrind, and sanitizers (address, thread, and memory).**](https://spinncode.com/designs/8hdv5HoV): Discover essential C++ debugging tools like GDB, Valgrind, and sanitizers to identify and fix issues in your applications. Learn how to use these tools for tasks such as memory error detection, performance optimization, and complex error diagnosis. By mastering these tools, you'll be able to write more reliable and efficient C++ code. - [**Performance profiling using `gprof` and modern tools (perf, VTune).**](https://spinncode.com/designs/Q99A3crw): Master performance profiling in C++ programming, identifying bottlenecks and optimizing code using traditional tools like `gprof` and modern alternatives including `perf` and Intel VTune Amplifier. By applying these profiling techniques and best practices, developers can significantly improve the efficiency and performance of their applications. #### Lab: - [**Write unit tests for your C++ code and use a debugging tool to track down and fix a memory issue.**](https://spinncode.com/designs/uOiUIkx9) #### Lab Summary: Master the art of testing and debugging in C++ by learning how to write unit tests with Google Test and track down memory issues with Valgrind. Discover how to harness the power of Google Test to verify your code's correctness, and utilize Valgrind to identify and fix memory leaks and other issues. By leveraging these essential tools, you'll write more robust and efficient C++ code. ### Week 11: Advanced C++ Features: C++20 and Beyond #### Topics: - [**Introduction to C++20 features: Modules, coroutines, and concepts.**](https://spinncode.com/designs/sp0FamAD): Explore the latest C++20 features, including modules, coroutines, and concepts, and learn how to use them to improve the performance and expressiveness of your C++ code. Master the art of writing more organized, flexible, and efficient code with these advanced techniques and features. - [**Coroutines in modern C++: Asynchronous programming and generators.**](https://spinncode.com/designs/7CjDDlEl): Master the power of coroutines in modern C++ with C++20, a feature allowing for efficient, asynchronous programming. Learn how to leverage this capability to write scalable code by understanding the concept, functionality, and implementation of coroutines. Discover how coroutines can simplify multitasking in your C++ programs. - [**Using C++20 ranges for cleaner, more expressive code.**](https://spinncode.com/designs/HFoAuK9M): Master C++20's range feature to write cleaner, more expressive code with greater readability and efficiency. This feature introduces a lazy way to process sequences of values, resulting in improved performance and code composition. Learn the basics of ranges, views, and adaptors, and discover how to apply them to create complex and efficient algorithms. - [**Modules in C++20: Breaking the limits of traditional header files.**](https://spinncode.com/designs/IDY7rZ1o): Master the latest advancements in C++, including C++20 modules, which replace traditional header files to provide faster compile times, improved dependency management, and simplified code reuse. This feature allows for more efficient code organization and compilation, making it an essential tool for modern C++ programming. By utilizing modules, developers can eliminate implicit dependencies and reduce preprocessor overhead, resulting in more efficient code development. #### Lab: - [**Refactor existing code to utilize C++20 features like coroutines and ranges.**](https://spinncode.com/designs/AHCsfGkv) #### Lab Summary: Master modern C++ programming techniques by learning how to refactor existing code to utilize C++20 features such as coroutines and ranges, improving code readability, maintainability, and performance. Explore how coroutines enable asynchronous code that is easier to read and maintain, and how ranges simplify working with sequences of data. Discover how to apply these features to real-world examples and take your C++ skills to the next level. ### Week 12: C++ Libraries and Real-World Applications #### Topics: - [**Overview of popular C++ libraries: Boost, Qt, and others.**](https://spinncode.com/designs/EECEwCtS): Mastering C++ programming involves more than just understanding the language – it also requires familiarity with the ecosystem of libraries that make development easier and more efficient. This overview covers popular C++ libraries such as Boost, Qt, and others, highlighting their key features, benefits, and applications in real-world projects. - [**Building and integrating third-party libraries into your project.**](https://spinncode.com/designs/lIMvwPZe): Building and integrating third-party libraries in C++ can significantly enhance a project's functionality. Popular build systems like CMake and Meson simplify the process, while libraries like Boost and Qt offer a range of community-driven tools. Mastering this skill can improve code quality, maintainability, and productivity. - [**Cross-platform development with CMake and other build systems.**](https://spinncode.com/designs/fSGZ0e32): Cross-platform development in C++ is essential for creating applications that run on multiple platforms. CMake is a popular build system that allows for platform-independent builds, and it's widely used in the C++ community for its simplicity and flexibility. Other notable build systems include Meson and Bazel, each with its strengths and characteristics. - [**Modern deployment techniques: Docker, cloud platforms, and CI/CD pipelines.**](https://spinncode.com/designs/tfDvVBOF): Master modern C++ deployment techniques with Docker, cloud platforms, and CI/CD pipelines. Learn how to isolate, scale, and automate the deployment of your applications for faster and more reliable delivery. #### Lab: - [**Build a small C++ project using CMake and deploy it using Docker.**](https://spinncode.com/designs/qUksPkiZ) #### Lab Summary: Build and deploy a C++ project using CMake and Docker by creating a simple calculator application, writing CMake configuration files, and deploying it using Docker containers through a step-by-step lab guide. Learn how to apply best practices for C++ coding standards, directory structure, and Dockerfile configuration. ## Final Project - **Description:** Develop a fully functional C++ application incorporating modern C++ features (e.g., templates, multithreading, RAII, and C++20 concepts). The project should showcase an understanding of performance, memory management, and software architecture. - **Presentation:** Students will present their projects, explaining design decisions, challenges, and lessons learned, followed by a live demo. ## Grading Breakdown - **Assignments&Labs:** 40% - **MidtermProject:** 20% - **FinalProject:** 30% - **Participation&Quizzes:** 10%