Asynchronous Programming Design Patterns CC++

Asynchronous Programming Design Patterns – C/C++, available at $64.99, has an average rating of 4.45, with 73 lectures, based on 70 reviews, and has 1437 subscribers.

You will learn about The Art of Asynchronous Programming How to Communicate in an Asynchronous way Writing a Computation Scheduler Reducing Multithreaded Application to Single Threaded Designing and Implementing Asynchronous Softwares Implementing Concurrency in a Single Threaded Applications Event Loop Design and Implementation Implementing blocking and Non-Blocking Calls This course is ideal for individuals who are Warning : Not for Absolute beginners in Programming or Who want to take their programming Skills from Beginner to Professional Level or Final year students looking to crack the Interview Questions on OS, Multithreading Concepts It is particularly useful for Warning : Not for Absolute beginners in Programming or Who want to take their programming Skills from Beginner to Professional Level or Final year students looking to crack the Interview Questions on OS, Multithreading Concepts.

Enroll now: Asynchronous Programming Design Patterns – C/C++

Summary

Title: Asynchronous Programming Design Patterns – C/C++

Price: $64.99

Average Rating: 4.45

Number of Lectures: 73

Number of Published Lectures: 66

Number of Curriculum Items: 76

Number of Published Curriculum Objects: 69

Original Price: $19.99

Quality Status: approved

Status: Live

What You Will Learn

The Art of Asynchronous Programming

How to Communicate in an Asynchronous way

Writing a Computation Scheduler

Reducing Multithreaded Application to Single Threaded

Designing and Implementing Asynchronous Softwares

Implementing Concurrency in a Single Threaded Applications

Event Loop Design and Implementation

Implementing blocking and Non-Blocking Calls

Who Should Attend

Warning : Not for Absolute beginners in Programming

Who want to take their programming Skills from Beginner to Professional Level

Final year students looking to crack the Interview Questions on OS, Multithreading Concepts

Target Audiences

Warning : Not for Absolute beginners in Programming

Who want to take their programming Skills from Beginner to Professional Level

Final year students looking to crack the Interview Questions on OS, Multithreading Concepts

30 Nov 2023 – This Course is under Development 

Welcome to the World of Asynchronous Programming!!

Asynchronous programming is used anywhere where your application interacts with other external entities – be it other threads, other processes. This world by its nature is Asynchronous. Asynchronous literally means – anything can happen anytime – unpredictable. How do you write software through Asynchronous programming? That’s what we shall be going to learn in this course.  Big software projects of reasonable sizes are Asynchronous. Software projects leave their synchronous boundaries the moment it starts integrating and communicating with external entities or go multithreaded.

Asynchronous programming is widely used in Distributed Systems, Networking Protocols, Distributes Databases, etc.

The prerequisite of this Course :

Know Thread Synchronization Concepts – Mutexes and Condition Variables ( any thread library, but we will be using pthreads )

C or C++ in preferable, but if your fav language is any other mainstream language then also it is ok. Borrow the concepts and implement it in your fav language.

Comfortable with basic Data structures such as Linked-List.

Zeal to learn and excel – beyond what Crowd is doing ( DS/ALGO/CP )

The end product of this Course shall be a mini library yet very powerful library which allows you do develop software through Asynchronous programming.

Course Difficulty Level :

The Course is level is Intermediate to Advanced. Very beginners pls refrain from enrolling into the Course.

Software Designing Problems to Address in this Course :

Problem 1. Simulating Concurrency in Single-Threaded Programs

problem 2. Reducing Multi-threaded Programs to Single Threaded

Problem 3. Work Deferrals

Problem 4. Asynchronous Communication

Problem 5. Queuing and Processing Incoming Network Packets

OLD Table Of Contents :

1. What is Synchronous Programming?

2. What is Asynchronous Programming?

3. When to use Asynchronous Programming?

4. Pre-requisites

5. Developing an Asynchronous Programming based Project

6. Adding a CLI user Input

7. Adding Listener Threads

8. Adding Timer

9. Adding Periodic Advertisements

10. Analyzing Problems in the projects

11. Designing Event Dispatcher ( Also Called Event Loop ) ( ED )

12. Integrating Event Dispatcher to the Project

13. Serializing User CLI input using ED

14. Serializing Timer Internal events using ED

15. Serializing Packet Processing using ED

16. Serializing Periodic Advertisements

17. Event Distribution using ED

18. Progressive Partial Processing using ED

19. Analyzing our Project

20. Futures and Promises

21. Promises Pipeline and Combinators

22. Thread Pools

23. Synchronous Vs Asynchronous Vs Concurrency

24. Creating Worker Threads for expensive work

Good luck ! Happy Learning.

After doing this course You would understand :

Problems with Synchronous programming

Design and Implement Asynchronous Application/Softwares

What type of applications/softwares must not be multi-threaded

What type of applications/softwares must be asynchronous

Say good bye to locking and thread synchronization for forever.

The Concepts you would learn in this course are portable to other programming languages of your choice

Course Curriculum

Chapter 1: Understanding the term Asynchronous

Lecture 1: Agenda

Lecture 2: Code Access for this Course

Lecture 3: Synchronous Vs Asynchronous Example 1

Lecture 4: Synchronous Vs Asynchronous Example 2

Lecture 5: Asynchronous Vs Multi-Threading

Lecture 6: Asynchronous Multi-Threading Design Models

Lecture 7: Course Layout

Chapter 2: Getting Started with Asynchronous Programming

Lecture 1: Goals of this Section

Lecture 2: Event Loop Internal Functioning

Lecture 3: Code Access for this Course

Lecture 4: Event Loop Data Structures

Lecture 5: init( ) and run( ) API Implementation

Lecture 6: Importing Helping APIs

Lecture 7: EL Thread Implementation

Lecture 8: Task Submission

Lecture 9: Demo 1 – Event Loop Usage Demo

Lecture 10: Demo 2 – Single Threaded Concurrency

Lecture 11: Why we need locking in Multi-threaded env ?

Lecture 12: Why Event Loops are lock free ?

Lecture 13: Event Loop provides Concurrency, but no Parallelism

Chapter 3: Design Pattern 1 – Serializing Multi-Threaded Flows

Lecture 1: Whats in this Section ?

Lecture 2: Overlapping & Non-Overlapping Work

Lecture 3: Is Multithreading Always Superior ?

Lecture 4: Complete Appendix C

Lecture 5: Defining Problem Statement

Lecture 6: Solution Discussion

Lecture 7: Setting up the Test Project

Lecture 8: Integrating Event Loop – Part 1

Lecture 9: Integrating Event Loop – Part 2

Chapter 4: Design Pattern 2 – Serializing Timers

Lecture 1: Agenda of this Section

Lecture 2: Get Familiar with the Timer Library

Lecture 3: Code Changes Recommended

Lecture 4: Timer Integration – Code Changes

Lecture 5: Event Loop Handling Timer Events

Lecture 6: Event Loop Summary

Chapter 5: Design Pattern 3 – Preemption and Rescheduling

Lecture 1: Why Preemtion is Important

Lecture 2: Implementing Preemption Support

Lecture 3: Preemption – Demonstration and Example in STP – Part1

Lecture 4: Preemption – Demonstration and Example in STP – Part2

Lecture 5: Assignment – Introduce a new Task to Serialize and send Data

Chapter 6: Design Pattern 4 – Task Prioritization

Lecture 1: Task Prioritization

Lecture 2: Task Prioritization Implementation

Lecture 3: Problems Addressed – Part 1

Lecture 4: Problems Addressed – Part 2

Chapter 7: Design Pattern 5 – Handling Premature Deletion

Lecture 1: What is Premature Deletion ?

Lecture 2: Solution

Lecture 3: Single Object Deletion

Lecture 4: Container Object Deletion – Part 1

Lecture 5: Container Object Deletion – Part 2

Chapter 8: Appendix A – Understanding Producer Consumer Synchronization

Lecture 1: Understanding Producer Consumer Synchronization

Lecture 2: Producer-Consumer Loop Hole Check

Chapter 9: Appendix B – Understanding Concurrency and Parallelism

Lecture 1: Why do we need Concurrency ?

Lecture 2: Concurrency Example 1

Lecture 3: Concurrency Example 2

Chapter 10: Appendix C – Adding Listener Threads

Lecture 1: Listener Threads – Responsibility Delegation

Lecture 2: Preparation of Implementation

Lecture 3: Network APIs and Demo

Lecture 4: Multi – Listener Application Implementation

Lecture 5: Listener Thread – Quick Code Walk

Chapter 11: Appendix D – Posix Timers

Lecture 1: Agenda and Prerequisites

Lecture 2: Timer Types

Lecture 3: Posix APIs for Timers

Lecture 4: Timer Design

Lecture 5: Timer Creation Steps

Lecture 6: Timer Implementation and Demo

Lecture 7: Bonus

Instructors

Abhishek CSEPracticals
I build Networks !

Ekta Ekta
Facilities Manager

Shiwani Nigam
Digital Marketing Executive

Rating Distribution

1 stars: 2 votes

2 stars: 0 votes

3 stars: 6 votes

4 stars: 16 votes

5 stars: 46 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!