DEV Community: felixfaisal

Polygon Fellowship Recap

felixfaisal — Thu, 18 Aug 2022 17:47:23 +0000

There is a handful of opportunities where you get to learn with highly motivated individuals and get paid for doing so, and Polygon Fellowship sits right at the top. The Polygon fellowship is of 8 weeks, wherein seven weeks are online, and the final week is spent IRL in a hacker house organized by Devfolio and Polygon.

Let me begin by discussing the first seven weeks of the fellowship, each week consists of an assignment, and the week is spent focusing on a specific use case of Blockchain such as DeFi, DAO, Storage etc. Blockchain is such a vast tech space that it is very intimidating for most beginners, but the curriculum is well designed to get a good glimpse of different areas of Blockchain. The resources and support provided by Devfolio are helpful, and the assignments certainly took away some of my weekends.

I was assigned to the ThirdWeb cohort and mentored by Samina and Raza. They were very helpful in ideating for my capstone project. They helped me understand how an end user perceives a decentralized application and what they would be ideally looking for in one. Every week we would have speakers give sessions related to the theme of the week and give us an insight into how they regularly dabble with these technologies at their workplace.

So more about the capstone project, All the beginner fellows had to demo a project on the final day of the fellowship, and we had to ideate and plan it during the seven weeks online. From the beginning of the fellowship, I have been ideating about finding a way to collect data by leveraging blockchain protocols. The aim was to ensure that we do not rely on someone's discretion and that they would not misuse our data to profit from it. It is pretty tricky to solve this problem at a grand scale, so I decided to make changes at an atomic level in the form collection services. During this period, I also found a teammate: Kundan Mishra, who shared the same vision as me about data collection services.

Now let's jump to the final week of the fellowship, the best week. Aniket from Devfolio had promised us that it would be ten times better and would also be better than another hacker house(shall not be named, lol). So expectations were high going in, and boy did they deliver. The hacker house was set up at a luxurious hotel in Bangalore, The Paul. Each of the fellows had their rooms inside two-bedroom suites. A grand hacker hall was created, consisting of 27-inch 4k monitors everywhere ( I hoped they would give me one of those as swag xD). We had sessions with industry experts every day for about 6-8 hours, each about different topics that were very interesting. I cannot recap all the sessions, but some of my favourite sessions were by Mudit Gupta from Polygon, Harsh from Polygon and Pranav Maheshwari from Graph Protocol. I enjoyed Mudit Gupta's session and was happy to know that he is a fellow Rustacean and had previously worked with Substrate, so I got to ask questions related to that.

Usually, or at least in my case, I rarely get to talk about Blockchain news with my friends and share insights; however, during the week, I got to discuss various Blockchain-related things openly. We had two significant hacks that week, which would be the first thing we discussed over breakfast. I remember asking about Blockchain Bridges being vulnerable to attacks. On the following day, We witnessed the chaotic nomad hack, which was ironic. Some fellows helped me understand the hack A-Z which was damn cool. The hacker hall was a fantastic place for coders to work during the night and have deep talks as the night progressed.

Lastly, I would like to talk about the swags we received, and there were so many. We received many T-shirts and a cool bag from Polygon, which I will always take with me. My favourite T-shirt was the latest NSB T-shirt by Devfolio. There are a lot of things I'm missing out here in this blog, but I can conclude that this is the best fellowship I've ever been a part of, and I hope beginners get a chance to be a part of it.

Rust VPP API Bindings | LFX Mentorship Project

felixfaisal — Fri, 10 Sep 2021 12:09:37 +0000

Hey Everyone, This article is about Rust VPP API Bindings project which was a part of LFX Mentorship. I had this amazing opportunity to work under the guidance of Andrew Yourtchenko on this project. So let's get started

What is VPP 🤔

FD.IO is an Open Source Dataplane developed by Cisco that runs in user space. At the heart of FD.IO is VPP which stands for Vector Packet Processor. So emphasis on Vector as opposed to Scalar Packet Processor wherein a single packet is processed at a time, VPP processes a vector of packets at a time which results in high performance.

It's like moving a load of marbles with a wheelbarrow instead of spoon

There are many exciting applications of VPP in Cloud Native and Networking space, I will be leaving links here for you to explore 🚀
Project Calico/VPP
VPP Case Study

Architecture 🧐

Here's the architecture of our project

VPP-API-Transport

This crate is responsible for establishing a connection to a running VPP process either via a socket or a shared memory interface. It also holds various functions for sending data via the connection.

VPP-API-Encoding

Encoding library holds various encapsulated data structures that are responsible for interacting with VPP. The library majorly ensures the deserializing and serializng of data structures are compatible with VPP. We are using serde+bincode for all serializing and deserializing to binary.

VPP-API-Driver

Driver library consists of functions that makes use of ingredients of Transport and Encoding which allows sending messages and receiving them easier. There are 3 types of messages that can be sent to VPP. (Referenced from Developer Documentation of VPP)

Request/Reply The client sends a request message and the server replies with a single reply message. The convention is that the reply message is named as method_name + Reply. Eg: SwInterfaceAddDelAddressReply
Dump/Detail The client sends a “bulk” request message to the server, and the server replies with a set of detail messages. These messages may be of different type. A dump/detail call must be enclosed in a control ping block (Otherwise the client will not know the end of the bulk transmission). The method name must end with method + Dump, the reply message should be named method + Details. The exception here is for the methods that return multiple message types (e.g. SwInterfaceDump). The Dump/Detail methods are typically used for acquiring bulk information, like the complete FIB table or details of all the existing Interfaces.
Events The client can register for getting asynchronous notifications from the server. This is useful for getting interface state changes, and so on. This a type of message that is not yet supported.

Here is a function that is responsible of sending Request/Reply message

pub fn send_recv_msg<'a, T: Serialize + Deserialize<'a>, TR: Serialize + DeserializeOwned>(
    name: &str,
    m: &T,
    t: &mut dyn VppApiTransport,
    reply_name: &str,
) -> TR {
    let vl_msg_id = t.get_msg_index(name).unwrap();
    let reply_vl_msg_id = t.get_msg_index(reply_name).unwrap();
    let enc = get_encoder();
    let mut v = enc.serialize(&vl_msg_id).unwrap();
    let enc = get_encoder();
    let msg = enc.serialize(&m).unwrap();

    v.extend_from_slice(&msg);
    println!("MSG[{} = 0x{:x}]: {:?}", name, vl_msg_id, &v);
    t.write(&v);
    loop {
        let res = t.read_one_msg_id_and_msg();
        // dbg!(&res);
        if let Ok((msg_id, data)) = res {
            println!("id: {} data: {:x?}", msg_id, &data);
            if msg_id == reply_vl_msg_id {
                let res = get_encoder()
                    .allow_trailing_bytes()
                    .deserialize::<TR>(&data)
                    .unwrap();
                return res;
            } else {
            }
        } else {
            panic!("Result is an error: {:?}", &res);
        }
    }
}

VPP-API-Gen

This is the most important part of Rust VPP, As it ingests Binary APIs and generates Rust bindings as a separate package which is nothing but the VPP-API.

VPP provides a binary API scheme to allow a wide variety of client codes to program data-plane tables. As of this writing, there are hundreds of binary APIs. Messages are defined in *.api files. However we are using Messages defined in *.api.json* which are self contained api files written in JSON format.

VPP-API-Macros

Macro library consists of procedural macros that make the generated rust bindings more ergonomic and provide sophisticated abstractions. The VPPMessage macro is a builder macro that allows you to initialize VPP messages in a less tiring fashion and also implements a derive for message name and crc. Another macro VPPUnionIdent creates accessor methods for the Union which makes it easier for the users to initialize it without having to fill the entire union.

Here is an example of using builder

let create_host_interface: CliInbandReply = send_recv_msg(
        &CliInband::get_message_name_and_crc(),
        &CliInband::builder()
            .client_index(t.get_client_index())
            .context(0)
            .cmd("create host-interface name vpp1out".try_into().unwrap())
            .build()
            .unwrap(),
        &mut *t,
        &CliInbandReply::get_message_name_and_crc(),
    );

Future and Testing

The integration tests currently only ensure if the messages are sent to VPP and received back without checking if it's the reply we are expecting, It has been added into the CI of the repository using GitHub Actions.
As mentioned earlier we do not support events messages as of now but hoping to develop it in the future.

Pull Requests 🤓

Here are all my pull requests:

Things I learnt 😎

This project is the best project I've worked on so far, I got to explore and implement many Rust features

Rust Macros: I learnt and implemented procedural macros using Rust and created VPP-api-macros which proved to be very useful in making the code abstracted.
Serde: I explored Serde which is a crate for serializing and deserializing, I was able to implement custom serialization and deserialization for EnumFlags and Unions.
VPP: It took me a while to get started and learn about VPP but by the end of the first half, I was able to grasp what VPP is and what it does.
Golang: I learnt Go to explore GoVPP bindings and understand their philosophy in generating bindings and possibly using some of it in Rust VPP.
Traits: Before the mentorship I was still struggling with properly understanding traits but during the course of the project I became much more confident about my understanding of traits
Functional Programming in Rust: Parts of the project has been written using concepts of Functional Programming, I sort of had to learn a bit of functional programming as I had mostly programmed using OOP.

Thank you 🥳

Shoutout to the Rust Foundation Discord Server for always helping me out with my queries be it how silly they were. Jon Gjengset for creating extensive videos on difficult parts of Rust, Linux Foundation for this amazing program that allowed me to work with Rust and lastly my mentor Andrew for guiding me at every step of the project.

Implementing Merge Sort in Rust

felixfaisal — Fri, 23 Jul 2021 13:57:49 +0000

Merge sort is arguably the most popular divide and conquer algorithm, It is one of the first algorithms any software engineer learns while learning algorithms and also while preparing for interviews. Let's implement merge sort in Rust

Divide and Conquer

Divide and Conquer is an algorithm design paradigm where we break down the problem statement into two or more parts until it can be solved directly.

Here we want to sort an array(or vector) in asceding order so we first break down the problem using recursion and then solve the problem.

Merge Sort Algorithm

Here's the psuedocode for merge sort algorithm

Step 1: Divide the array into two parts 
Step 2: Sort one half of the array 
Step 3: Sort second half of the array 
Step 4: Merge the two halfs
Step 5: Perform these operations recursively

Let's visualize this psuedocode using a diagram

Rust code

fn merge_sort(mut arr: Vec<i32>, left: usize, right: usize) -> Vec<i32> {
    if right - 1 > left {
        let mid = left + (right - left) / 2;
        arr = merge_sort(arr, left, mid);
        arr = merge_sort(arr, mid, right);
        arr = merge(arr, left, mid, right);
    }
    arr
}

Here right - 1 > left is the terminating condition meaning that the array cannot be divided anymore. We calculate the midpoint of the array and then divide them further recursively after which we merge the arrays by calling merge(arr, left, mid, right).

fn merge(mut arr: Vec<i32>, left: usize, mid: usize, right: usize) -> Vec<i32> {
    let n1 = mid - left;
    let n2 = right - mid;
    let mut L1 = arr.clone();
    let mut R1 = arr.clone();
    let L = &L1[left..mid];
    let R = &R1[mid..right];
    /* Merge the temp arrays back into arr[l..r]*/
    let mut i = 0; // Initial index of first subarray
    let mut j = 0; // Initial index of second subarray
    let mut k = left; // Initial index of merged subarray
    while i < n1 && j < n2 {
        if L[i] < R[j] {
            arr[k] = L[i];
            i = i + 1;
        } else {
            arr[k] = R[j];
            j = j + 1;
        }
        k = k + 1;
    }
    while i < n1 {
        arr[k] = L[i];
        i = i + 1;
        k = k + 1;
    }
    /* Copy the remaining elements of R[], if there
    are any */
    while j < n2 {
        arr[k] = R[j];
        j = j + 1;
        k = k + 1;
    }
    arr
}

Here we merge the two sorted sub arrays in ascending order into a single array, We do this by checking less than condition and then inserting into the array.

Output

Let's run these functions using a main function

fn main() {
    let mut arr: Vec<i32> = vec![64, 34, 25, 8, 22, 11, 9];
    arr = merge_sort(arr.clone(), 0, arr.len());
    println!("Sorted array is {:?}", arr);
}

Here's the output!

    Finished dev [unoptimized + debuginfo] target(s) in 2.83s
     Running `target/debug/rust-code-gen`
Sorted array is [8, 9, 11, 22, 25, 34, 64]

There are definitely better ways of implementing this algorithm. Implementing fundamental algorithms in Rust can help beginners understand Rust better and feel more confident.

Implementing Linked List in Rust

felixfaisal — Thu, 13 May 2021 12:54:01 +0000

Linked List is one of the most known data structures implemented in every language. It is used to build data structures on top of it such as stack or queue etc. It is difficult to implement Linked List in Rust as what is allowed in most languages is simply not allowed in Rust, While it may seem to be a little difficult but the Rust compiler also at the same time makes sure that your code is memory safe.

Linked List

A linked list is a collection of nodes connected to each other via pointers. It is stored on the heap as it allows it to grow or shrink when the program is being executed.

Implementation

Define an enum for address node



#[derive(Clone)]
enum address {
    address(Box<myList>),
    Nil,
}

The reason why I'm choosing to use an Enum for address is because Rust doesn't provide Null types so suppose there is only one element in the Linked list then it is supposed to have a null address. This can also be solved by using Option but I'm using an Enum instead.

Define List Structure



#[derive(Clone)]
struct myList {
    value: u32,
    next: address,
}

CRUD Methods for Linked List



impl myList {
    fn append(&mut self, elem: u32) {
        match self.next {
            address::address(ref mut next_address) => {
                next_address.append(elem);
            }
            address::Nil => {
                let node = myList {
                    value: elem,
                    next: address::Nil,
                };
                self.next = address::address(Box::new(node))
            }
        }
    }

This creates a new node and appends it to the end of the list.



    fn delete(&mut self, elem: u32) {
        match self.next {
            address::address(ref mut next_address) => {
                if next_address.value == elem {
                    println!("Deleting value {}", next_address.value);
                    self.next = next_address.next.clone();
                } else {
                    next_address.delete(elem);
                }
            }
            address::Nil => {
                if self.value == elem {
                    self.value = 0;
                } else {
                    println!("Element {} does not exist in the linked list", elem);
                }
            }
        }
    }

This function first finds the elements to delete then deletes it by changing the address of its previous node to the address of its next node. However, this implementation doesn't check if the head node has the element or not.



   fn count(&self) -> u32 {
        match self.next {
            address::address(ref newaddress) => 1 + newaddress.count(),
            address::Nil => 0,
        }
    }
 fn list(&self) {
        if self.value == 0 {
            println!("The list is empty")
        } else {
            println!("{}", self.value);
            match self.next {
                address::address(ref next_address) => next_address.list(),
                address::Nil => {}
            }
        }
    }

The count function counts the number of elements present in the linked list and the list function prints all the elements present in the array. Both of these functions are implemented recursively.

Lastly, We have the update function which takes in the position and the element that needs to be updated, This function is implemented iteratively.



fn update(&mut self, index: u32, elem: u32) {
        let mut i = 0;
        let mut j = self;
        if i == index {
            j.value = elem;
        }
        while i < index {
            // println!("{}", j.value);
            match j.next {
                address::address(ref mut next_address) => j = next_address,
                address::Nil => {}
            }
            i = i + 1;
        }
        j.value = elem;
    }

Now let's have a look at our main function



fn main() {
    let mut head = myList {
        value: 8,
        next: address::Nil,
    };
    head.append(9);
    head.append(10);
    head.append(11);
    head.list();
    println!("The size of the list is {}", head.count());
    head.update(4, 20);
    head.update(0, 6);
    head.list();
}

We first define the head element and then perform the following CRUD operations, Let us see what output we get when we perform cargo run



   Finished dev [unoptimized + debuginfo] target(s) in 0.29s
     Running `target/debug/algo`
8
9
10
11
The size of the list is 3
6
9
10
20

This is not a perfect implementation as you can see I've missed out on several edge cases which I'm looking forward to addressing in my next blog. It's an implementation that works really well and I'd encourage you to try it out and make it much better.