Build Remote Procedure Calls (RPC) - from scratch in C from Udemy

About This course is about Developing your own Remote procedure calls - I will use Linux OS for this course, however you can use Windows OS if you are used to it. The essence and real strength of this course is No use of any third party libraries. I follow this principle in all my other courses. Whatever you learn through my courses, you learn from absolute ground level. This course does not violate the principle and teaches you how to build Remote Procedure Calls step by step from absolute scratch - No framework, tools, supporting libraries or anything - just pure C.

This course actually lays the foundation of many future System Software Projects. Few of which are below and is a part of this course curriculum.

Remote Procedure Calls (RPC) is a technique to invoke the function/procedure which actually resides on different physical machine running somewhere else in the network - hence the name remote procedures. In this course, you will learn the concepts working behind the scenes. The same concepts can be extended to implement other system programming concepts, besides RPC, such as - Data Synchronization and Check-pointing the application state. This course promise to deliver the complete content on developing RPCs in its initial release.

Data Synchronization - It is a process to synchronize the complete application Heap state to remote machine. The remote machine will build the mirror heap state. In the event, the first machine fails, the remote machine can take over as it has all the state required to resume the operation of failed machine.

Check pointing - It is a process of saving the application Memory state to disk/file persistently, so that, the application can be restarted/resumed any time building the exact same Memory state from Memory snapshot stored earlier to secondary storage.

Check pointing shall be delivered in subsequent releases of this course.

Who should do this course ?

Beginners Please take this course at your discretion. You should be good with C pointers and how C objects are laid out in memory. I expect you to be at-least above beginner level in C programming. This means, that only very enthusiastic students who wants to get an edge over the smartest student in their college should enroll. Average students Pls excuse. Job seekers and professional developers Must enroll. The concepts you learn from this course is language agnostic and having learned them will enable you to implement the RPC/Data-Synch/Checkpointing in any programming language of your choice. If tomorrow you happen to work in Java, you shall be knowing how RPCs work at the lowest level of implementation.

Pre-requisite

C and being good at pointers is a pre-requiste of this course. A minimal socket programming back-ground is desirable but not mandatory. We designed this course starting from absolute basics and building the foundation of learners first before actually pulling the course at full throttle. If you are not good with pointers and memory manipulation in C, Pls enroll only after meeting the pre-requisite criteria.

Also, Please just do not sit and watch my codes. Write your own codes, even if it is same as mine .

Programming Language used In this course :

We have a strong reasons to choose C as a language for this course:

RPC is a technique which if knowing the concepts can be implemented in any programming language of your choice. Learning RPC using C helps you understand what is going on behind the scenes. C language really exposes the low level details about how system actually works. In System programming, C is the only language to be used and there is not even a remote substitute of this language when it comes to System programming.

No Third Party libraries

Whatever logic you implement, you need to implement it from scratch, beginning from #include <stdio.h>. This course do not suggest taking help of any third party library to get the jobs done. Use of external libraries completely defeats the purpose of the course. However, it is recommended to use third party libraries for commonly used data structures such as linked lists/Trees/Queues etc which saves a lot of time implementing these data structures.

Related Courses

RPC is one way of carrying out Inter Process Communication between two processes running on separate machines in the network. You may also want to check my another course in which Linux IPC techniques has been discussed.

Warning : This course has auto system-generated subtitles which may not be perfect. Please disable subtitles as per your convenience.

Curriculum

This Course is divided into two major parts -

1. Understanding the Concept of Serialization and DeSerialization in great detail

2. Using the Serialization and DeSerialization to actually solve/build system. This includes :

Building Remote Procedure Calls
State Synchronization
Check pointing the application state

Section

Section 7, 8, 9 are dedicated to build and develop above stated systems

Section 1 - Get Started
- Table Of Contents of the Entire Course
- Linux Installation for Beginners
Section 2 - What is Serialization and Why we need it ?
Section 3 - Concept of Data Serialization and DeSerialization
- Serializing and DeSerializing Simple C Structures
- Serializing and DeSerializing Nested C Structures
- Serializing and DeSerializing Pointer C Structures
Section 4 - STREAMS - A Data Structure
- Design and Implementation
Section 5 - Data Serialization and DeSerialization Implementation in C
- Serializing and DeSerializing Simple C Structures
- Serializing and DeSerializing Nested C Structures
- Serializing and DeSerializing Pointer C Structures
- An Example
Section 6 - Serializing Generic Data structures
- Use Function Pointers to Serialize void *
Section 7 - Implementing Remote procedure calls from Scratch
- Understanding RPC Concept and Design
- Developing Client Stubs - Marshalling of RPC Arguments
- Developing Server Stubs - UnMarshalling of RPC Arguments
- Developing Server Stubs - Marshalling of RPC Return Type
- Developing Client Stubs - UnMarshalling of RPC Return Type
- Concept of RPC Identity
- RPC Use Cases
Section 8 - State Synchronization
Section 9 - Checkpointing (Coming Soon)

Audit Trial

30 Sept 2018 - Added Section 8 on State Synchronization

29 Sept 2018 - Added Section 6 on Serializing Generic Data structures

What's inside

Learning objectives

Shall be able to build remote procedure calls starting from #include <stdio.h>
Will understand the concept of data serialization and deserialization
Understand the concept of application state synchronization
Understand the concept of application state checkpointing

Will understand how to manipulate data objects as stream of bytes
Will be able to understand how to manipulate the objects recursively
Will be able to extend and apply the concepts learned in other programming languages
Will understand the pre-requistes required for data transmission between heterogeneous machines

Shall be able to build remote procedure calls starting from #include <stdio.h>
Will understand the concept of data serialization and deserialization
Understand the concept of application state synchronization
Understand the concept of application state checkpointing
Will understand how to manipulate data objects as stream of bytes
Will be able to understand how to manipulate the objects recursively
Will be able to extend and apply the concepts learned in other programming languages
Will understand the pre-requistes required for data transmission between heterogeneous machines

Syllabus

Get Started

Table of Contents

Join Telegram Group

Introduction

Let us Learn the Basics of Serialization and DeSerialization in this Section. After this Section you will understand What is meant by Data (De)Serialization

Follow the example, multiply.c to complete this assignment. Shoot any Questions in QnA section, I will help you out.

hint : Write down serialie/Deserialize routines for all the structures involved in the question - Linked List, Linked List node, person_t.

For a Given RPC, write down 4 RPC routines.

Implement the same 9 steps we discussed. Remember to free any memory that you malloc after use.

Traffic lights

Read about what's good

what should give you pause

and possible dealbreakers

Teaches RPC, data synchronization, and checkpointing, which are valuable concepts for understanding system software projects and their underlying mechanisms

Requires proficiency in C, particularly with pointers and memory manipulation, which may pose a challenge for beginners without a solid foundation

Uses C to expose low-level details of system operations, offering insights into how systems function at a fundamental level, which is essential for system programming

Avoids third-party libraries to provide a ground-level understanding of RPC implementation, which may require more effort but offers deeper insights

Explores data synchronization and checkpointing, which are crucial for building robust and fault-tolerant distributed systems, enhancing the course's relevance

Covers serialization and deserialization in detail, which are fundamental concepts for understanding data transmission between heterogeneous systems, providing a solid foundation

Reviews summary

Deep dive into rpc in c

According to learners, this course offers a deep, from-scratch exploration of Remote Procedure Calls (RPC) using C. Students particularly appreciate the detailed focus on serialization and deserialization, viewing it as a fundamental and valuable concept taught exceptionally well. The course's unique approach of building everything from the ground up, without relying on third-party libraries, is highlighted as a major strength, providing clear insights into underlying mechanisms. While the course is considered challenging and requires a solid background in C, especially pointers, those with the necessary prerequisites find it highly rewarding and insightful. The content on state synchronization is also noted as a useful addition. Some mention the need for active coding practice to fully grasp the material. Overall, it's seen as a strong foundation for system programming.

Checkpointing module is noted as pending addition.

"The course description mentions Checkpointing but notes it's 'Coming Soon'. It wasn't present when I took it."

"I'm looking forward to the Checkpointing section being added."

"It would be great if the promised Checkpointing module was completed."

Includes valuable sections on state synchronization.

"The addition of the state synchronization section was a big plus."

"Understanding state synchronization using serialization was very insightful."

"I wasn't expecting the state sync part, but it's highly relevant and well-explained."

Focuses on hands-on coding and real-world implementation.

"The coding exercises and examples reinforced the concepts learned in lectures."

"Actually building the RPC system hands-on solidified my understanding."

"It's not just theory; you get to write a lot of code."

"The demos were crucial for seeing how the pieces fit together."

Concepts are explained clearly and logically.

"The instructor does a great job explaining complex system-level concepts."

"I found the explanations very clear, even for topics I was unfamiliar with."

"The step-by-step breakdown of the RPC process was easy to follow."

"He explains the 'why' behind the implementation decisions, which is very valuable."

Excellent coverage of data serialization principles.

"The detailed explanation of serialization and deserialization is worth the price of the course alone."

"Understanding serialization from this course helped me in many other areas of system programming."

"The sections on handling different C structures and pointers during serialization were particularly helpful."

Builds core concepts entirely from scratch.

"Learning to build everything from scratch gave me a deep understanding of how RPCs work."

"The no third-party libraries approach is fantastic; it really forces you to understand the low-level details."

"I appreciate how the course builds RPCs piece by piece, explaining every detail."

"It's great to see how serialization and RPC work internally without abstracting it away."

Demands solid C knowledge, especially pointers.

"You definitely need to be comfortable with C pointers and memory allocation before taking this."

"The course assumes you're already proficient in C; it's not for absolute beginners."

"If you're not good with C memory models, you'll struggle with some parts."

"Make sure your C fundamentals are strong; the pace is fast otherwise."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Build Remote Procedure Calls (RPC) - from scratch in C with these activities:

Review C Pointers and Memory Management

Show steps

Strengthen your understanding of C pointers and memory management, which are crucial for understanding serialization and deserialization in the course.

Browse courses on C Programming

Show steps

Review pointer arithmetic and common pointer errors.
Practice allocating and freeing memory using malloc and free.
Work through examples of dynamic data structures like linked lists.

Review: 'Computer Networking: A Top-Down Approach'

Show steps

Gain a deeper understanding of networking concepts to better grasp the role and implementation of RPCs.

View Computer Networking [Global Edition] on Amazon

Show steps

Read chapters on network protocols (TCP/IP, UDP).
Focus on the transport layer and its role in reliable communication.
Understand the client-server model and its implications for RPC design.

Implement a Simple Client-Server Application

Show steps

Practice socket programming to solidify your understanding of network communication, which is essential for building RPCs.

Show steps

Write a simple server that listens for connections on a specific port.
Write a client that connects to the server and sends a message.
Implement basic error handling and message formatting.
Extend the application to handle multiple clients concurrently.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Serialization/Deserialization Exercises

Show steps

Reinforce your understanding of serialization and deserialization by working through practical coding exercises.

Show steps

Serialize and deserialize simple C structures (int, float, char).
Serialize and deserialize nested C structures.
Serialize and deserialize C structures containing pointers.
Handle memory allocation and deallocation during serialization/deserialization.

Create a Blog Post on RPC Concepts

Show steps

Solidify your understanding of RPC concepts by explaining them in a clear and concise manner in a blog post.

Show steps

Research and summarize the key concepts of RPCs.
Explain the steps involved in an RPC call (marshalling, transport, unmarshalling).
Discuss the advantages and disadvantages of using RPCs.
Provide examples of real-world applications of RPCs.

Contribute to an Open-Source RPC Project

Show steps

Gain practical experience by contributing to an existing open-source RPC project.

Show steps

Find an open-source RPC project on platforms like GitHub.
Study the project's codebase and documentation.
Identify a bug or feature to work on.
Submit a pull request with your changes.

Review: 'Advanced Programming in the UNIX Environment'

Show steps

Deepen your understanding of system-level programming concepts relevant to RPC implementation.

View Advanced Programming in the UNIX Environment... on Amazon

Show steps

Read chapters on interprocess communication (pipes, message queues, shared memory).
Focus on the sections related to network programming and sockets.
Understand the concepts of concurrency and synchronization in system programming.

Career center

Learners who complete Build Remote Procedure Calls (RPC) - from scratch in C will develop knowledge and skills that may be useful to these careers:

Systems Programmer

A systems programmer designs, develops, and maintains operating systems and system software components. This often includes working with low-level languages such as C. This course provides a solid understanding of how systems work under the hood, especially regarding remote procedure calls. The course's hands-on approach, building RPCs from scratch, will translate directly to the practical skills needed in systems programming where understanding the fundamentals is key. The emphasis on no third-party libraries aligns with the need for systems programmers to deeply understand system internals. It covers the essentials required for proficiency as a systems programmer.

See salaries and explore the career path for Systems Programmer

Kernel Developer

A kernel developer works on the core of an operating system. This course focuses on low-level system programming concepts such as Remote Procedure Calls, data synchronization, and checkpointing. This course will allow kernel developers to learn how systems interact at the lowest levels. The skills taught in this course are directly applicable to kernel development, where understanding the intricacies of system calls and inter-process communication is essential. Kernel developers can leverage this course to deepen their understanding of operating system fundamentals.

See salaries and explore the career path for Kernel Developer

Distributed Systems Engineer

A distributed systems engineer designs, implements, and maintains distributed systems for scalability and reliability. Remote Procedure Calls play a huge role in distributed systems, enabling communication between different services. This course focuses on building Remote Procedure Calls from scratch, which provides a deep understanding of the underlying mechanisms necessary for distributed systems. A distributed systems engineer should enroll in this course to learn how to implement RPCs and other inter-process communication techniques in practice. The coverage of data serialization and deserialization is directly applicable for data transfer in distributed environments.

See salaries and explore the career path for Distributed Systems Engineer

Network Programmer

Network programmers write code that enables communication between devices over a network. This course provides a solid foundation in Remote Procedure Calls, which are a key technology for client-server communication. By learning how to build RPCs from scratch, network programmers gain a deep understanding of the underlying protocols and data formats. The course's emphasis on data serialization and deserialization is directly relevant to network programming. Network programmers can use this course to become expert in network communications.

See salaries and explore the career path for Network Programmer

Embedded Systems Engineer

An embedded systems engineer develops software for embedded devices, often working with limited resources. This course emphasizes building RPCs from scratch using C, which are essential skills in embedded systems development. The knowledge of data serialization and deserialization is crucial for efficient data handling in resource-constrained environments. The focus on low-level system programming makes this course particularly relevant. Check pointing the application state is a bonus. One who wishes to become an embedded systems engineer should take this course.

See salaries and explore the career path for Embedded Systems Engineer

Software Engineer

A software engineer designs and develops software applications. This course emphasizes building Remote Procedure Calls from the ground up, ensuring a deep understanding of the underlying principles. While software engineers may not always work at the systems level, understanding these low-level concepts from this course helps them write more efficient and robust code. Knowledge of RPCs can be invaluable when designing microservices or other distributed components. By understanding serialization and deserialization, a software engineer can be more proficient. This is a course a software engineer can leverage to improve their skills.

See salaries and explore the career path for Software Engineer

Reverse Engineer

A reverse engineer analyzes software to understand its functionality, often without access to the source code. This course, with its focus on building systems from scratch, helps reverse engineers understand how software components interact at a low level. Understanding data serialization and deserialization, as taught in this course, is an invaluable skill when reverse engineering network protocols or file formats. The ability to understand system-level details makes this course particularly useful for someone aiming to become a reverse engineer. Knowledge of Remote Procedure Calls is a plus.

See salaries and explore the career path for Reverse Engineer

Performance Engineer

Performance engineers analyze and optimize the performance of software systems. This course focuses on building systems from scratch, including Remote Procedure Calls. This course also includes an understanding of data synchronization. Performance engineers can use this to deeply understand the system bottlenecks that exist in order to tune them. It can be useful for performance engineers given its focus on implementation from scratch and building up low-level understanding.

See salaries and explore the career path for Performance Engineer

Security Engineer

A security engineer works to protect computer systems and networks from threats. They are required to analyze systems, identify vulnerabilities, and develop security measures. This course covers low-level system programming concepts, specifically the building of Remote Procedure Calls from the ground up. Understanding how RPCs work and manipulating data objects as streams of bytes can help security engineers identify and prevent exploits that target these communication channels. Data serialization and deserialization is important for unpacking network messages. A security engineer may find this course applicable to the work that they do.

See salaries and explore the career path for Security Engineer

Software Architect

A software architect designs the high-level structure of software systems. While architects may not write code daily, understanding low-level system programming concepts helps them make informed decisions about system design. This course covers building Remote Procedure Calls from scratch, which provides insights into the performance and scalability considerations of distributed systems. This course also provides an understanding of data serialization and deserialization. By understanding the trade-offs involved in different communication methods, the software architect can design more robust and efficient systems.

See salaries and explore the career path for Software Architect

Cloud Engineer

A cloud engineer designs, implements, and manages cloud computing infrastructure and services. This course covers building Remote Procedure Calls from scratch, which provides a foundation for understanding distributed systems in the cloud. The emphasis on data serialization and deserialization is also relevant, as cloud services often need to exchange data in different formats. Cloud engineers will be able to gain proficiency through this course.

See salaries and explore the career path for Cloud Engineer

Site Reliability Engineer

A site reliability engineer focuses on the reliability, scalability, and performance of systems. The understanding of Remote Procedure Calls provides engineers with the skills to design and troubleshoot distributed systems. This course covers state synchronization. By understanding these concepts, site reliability engineers can build more resilient and fault-tolerant systems. This course may be useful for those looking to become site reliability engineers.

See salaries and explore the career path for Site Reliability Engineer

Data Engineer

Data engineers design, build, and maintain data pipelines and infrastructure. This course focuses on data serialization and deserialization, which are core concepts in data engineering. Data engineers often need to convert data between different formats and systems, and understanding these concepts is essential. Data engineers can better manage the flow of data through their systems by understanding low-level data manipulation techniques. The knowledge of Remote Procedure Calls may be useful in distributed data processing architectures. This course may be useful to data engineers.

See salaries and explore the career path for Data Engineer

DevOps Engineer

A DevOps engineer automates and streamlines the software development and deployment process. This course focuses on building systems from scratch, emphasizing low-level details. Data serialization and deserialization knowledge is also useful. The conceptual clarity that is gained may enable DevOps engineers to create more efficient and reliable deployment pipelines. DevOps engineers may find this applicable to their work.

See salaries and explore the career path for DevOps Engineer

Database Developer

A database developer designs and implements database systems. Remote Procedure Calls can be used to interact with databases in distributed environments. This course provides a foundation in building RPCs, which can be helpful for database developers who need to implement custom communication protocols. This is relevant to the work of a database developer. This course also covers data serialization and deserialization. By understanding the underlying principles of RPCs, database developers can design more efficient data access layers.

See salaries and explore the career path for Database Developer

Build Remote Procedure Calls (RPC) - from scratch in C

What's inside

Learning objectives

Syllabus

Traffic lights

Save this course

Reviews summary

Deep dive into rpc in c

Activities

Career center

Reading list

Share

Similar courses