Research Assistant at UNT

1. Distributed system engineer.
   • Worked on an open-source blockchain (Nimiq) for implementing the Proof of Concept of my research.
   • Able to navigate and work with a large code base. For this work, I had to work with around 40000 lines of code.
   • Excellent understanding of the following concepts :
     • Consensus in distributed systems
     • Fault Tolerance
     • Peer-to-Peer protocols
     • Message passing protocol like Gossip, Kademlia
     • Distributed data consistency
     • Distributed data replication
     • Load Balancing
     • Monitoring systems like Prometheus, Open Telemetry
     • Intermediate to advanced understanding of the Rust lang
   • More detail below
2. Machine learning engineer.
   • Designing an autonomous agentics framework for problem solving.
   • Proficient with architectures like CNN, RNN, and initially used LSTM for the autonomous agentic framework, which revealed limitations with this approach.
   • Experience with using HugginFace for building pipelines.
   • Used the PEFT method (LORA) for LLM fine-tuning.

Software engineering

FullStack Engineer at RedChillies Labs, Inc

FullTime - (Dec 2021 - July 2023) - Company Closed.

Built a lot of applications in RedChillies. Built games for the Zilliqa blockchain, built an advanced option market which was the exact replication of polkamarket for Zilliqa. Our major highlight was building and launching Checkchain, where we were able to secure around 200,000 USD.

RedChillies was a DAO that all of us started together. So, the takeaway here deals more with the management side than the development and engineering side

• Key takaways:
  1. Significant increase in skill: from learning about Scilla at Pastel to now building a complex options market on Zilliqa.
  2. Went from building and hosting simple RESTful applications to building applications using microservices, load balancers, message queuing, GraphQL, and more.
  3. Highs and lows: periods with strong funding instilled confidence, as periods with low funding brought on stress and pressure.
  4. It was during such time we moonlighted and worked in other places whilst continuing experimentation with new projects.
  5. Many of our in-house projects, like ZilChil (Chess in Zilliqa), PredictionDex (Sports prediction market), initially succeeded but failed later on.
  6. Some projects didn’t even make it to launch due to the lack of funding to deploy them.
  7. Learned that a project’s success depends on its delivery than its novelty.
  8. We won big with CheckerChain but even that success was short lived.

Research and Development Engineer at Cedro

FullTime - (May 2023 - July 2023) now Twine

At Cedro, I had one job: to research and draw out the plans to transition Cedro from a Layer 1 to a Layer 2 platform. My work was cut short as I had to move to the US. Besides this, I was also involved in finalizing the fee calculation formula used by Cedro’s DEX.

• Key takaways:
  1. Used a differential equation for the first time in the real world to finalize the formula.
  2. Introduced to blockchain research and system architecture.

Software Developer at Zebec protocol

Part-Time (June 2022 - October 2022)

At Zebec, we had one goal. To add the message passing protocol Wormhole to their existing infrastructure. This was the hardest task I have done so far. It felt impossible at that time.

• Key takaways:
  1. Learned to navigate under pressure like never before. I would get dreams (nightmares) where I was still working; I literally worked in my sleep.
  2. Was introduced to Rust lang <3.
  3. There was little to no documentation for the wormhole. So, we had to study their code and build using that.
  4. Communication skill was developed as we were working closely with the wormhole team. They were testing their protocol through us. We had regular meetings and communication streams.

Software Developer at Pastel Software Solutions

FullTime - (April 2021 - Dec 2021) - Company Closed.

Disclaimer Pastel Software and RedChillies were sister companies. In my resume, I include the work in Pastel under RedChillies to save space.

• Built one of the first ERC-1155 trading DEX with Vuzec, a music tokenization platform.
• We worked closely with the team at Zilliqa blockchain building out product and projects for them.
• We were funded by Zilliqa to build an extensive documentation for Scilla, the programming language they use.
• We were also funded by Zilliqa to build their multitoken standard, which we did, but it was never implemented.
• Key takaways:
  1. Learned how to read code. For Vuzec, we had to understand all of Uniswap DEX and replicate and extend its features.
  2. I was introduced to functional programming language for the first time as Scilla was a language built on top of/using OCaml.
  3. I was recognized globally for my skills in Scilla when I won the Scilla optimization competition.
  4. I picked up Scilla relatively quickly and thus found myself leading the team because of it.

Intern at Ibriz.ai

FullTime - (Nov 2020 - Dec 2020)

• At Ibriz, I was assigned the role of testing out the python applications being built on the Icon Blockchain.
• I was involved with projects like OMM and Balanced Network.
• The project OMM was a fast-paced project with a team of 3 developers working on it. I had to quickly understand the code in order to write tests for it.
• Key takeaway: I learned to work in a fast-paced team and quickly navigate a large code base.

---

Joy of Building

I have always loved building and hacking away with the goal to impress or show it to no one. I still do this to this day, as much as I can. Here is the list of things I’ve built over the years just because I love to program and learn while doing it.

• BitTorrent
  • The culmination of my love for Rust and distributed systems.
• Grep
  • Wanted to try Go as well as build something real.
• Knight Tour Problem
  • During 2023, I was a bit into problem-solving and visualization, so I built this after seeing it on YouTube Shorts.
• Fourier Artist
  • I cannot draw, but I still wanted to draw my girlfriend. So, I drew her using the Fast Fourier Transform.
  • Thank you to teacher like Coding Train who taught me how to do this.
• Microservices:
  • Taught by Dr Ben on his fantastic software engineering class.
  • Used microservices built using Spring, where we implemented producers and consumers for creating and processing requests.
  • Used RabbitMQ as a queuing system for the producers.
  • Did it for my CSCE 5430 class, so I cannot open-source the code.
• Compiler:
  • I have recently built a full C++ compiler using Java, JavaCup, and JFlex.
  • Taught by Dr Maharjan in his fantastic compiler class.
  • Did it for my CSCE 5650 class, so I cannot open-source the code.
  • 10/10 on the difficulty scale, 11/10 on the sense of achievement scale.
  • In the past, I attempted to write a compiler in C, but failed miserably due to the complexity of the program.
• Artificial Intelligence:
  • Taught by Dr Pears in his fundamentals of AI class CSCE 5210.
  • Best assignments I’ve done in my life.
  • We had to build systems based on the concepts he covered in his class.
  • Implement a search algorithm
    • Built the brains for a ride-sharing app.
    • We were taught A* search algorithm.
    • Our assignment was to implement A* on a rectangular grid where a car will go pick up customers and drop them off.
    • There was 1 car, and many customers can generate requests in a given unit of time.
    • We had to use A* to go pick up the nearest customer.
    • Decide to drop off one of the customers or go pick up another one (if there is space in the car).
    • Very fun to build!
  • Implement our version of Edmond’s Karp Algorithm
    • Maximize a flow through a flow network
    • We used hill climbing, which was taught in class as a heuristic to build this.
  • Application of Reinforcement learning
    • For a ride-sharing app, there are general and premium customers
    • When a ride request is received, the agent (Car) will use reinforcement learning to select the customer that maximizes its reward
• Reinforcement Learning projects:
  • Wanted to learn about RL after watching the AlphaGo documentary.
  • Used Q learning to build a maze-solving agent.

• Undergrad Capstone Project: Spotify on the Blockchain

• Build Neurons for different kinds of neural net:
  • Undergrad 3rd year course assignment.
  • One of the 1st fun project.
  • Taught me the Joy of building.
  • Been chasing the high ever since.

---

Research Detail

First things first

The people at Nimiq Sorren and Dr. Pascal were incredibly helpful to me when I reached out to them in the earlier phases of my work. Dr. Pascal specially helped me figure out how to get the client running, as well as sat with me multiple times and answered my questions on Nimiq’s architecture early on. I am sure without him, I would not have been able to do what I did.

Dr. Pascal, thank you. You’re the best!!!

How did I pick Nimiq?

The first part of the problem was to pick a blockchain to modify for my proof of concept. During my work career, I had done some work on and explored Nimiq. Since my work does not need smart contracts, I could “make my life easier,” as Dr. Dantu puts it, by selecting a relatively simple blockchain. So, I decided to pick Nimiq. Nimiq had two flavours then (it only has one now). Nimiq was the world’s first browser-based blockchain, where you could start mining using a browser. For this, their code base had to be succinct and to the point, and could not be bloated. So, the implementation for this was written purely in JavaScript and had A PoW consensus. The other option was a PoS client for Nimiq that was written purely in Rust. Despite my love for Rust, I picked the JS version to “make my life easier”. And let me tell you something, the code is brilliant. It proves that there are no bad languages, only bad developers.

Needle in a haystack

Figuring out what does what in a code with 40000 lines of code is tough. Since my 1st week as an intern at Ibriz, I’ve always easily been able to navigate and find my way around a large code base (I think it’s a skill I have). With this and Dr. Pascal’s initial help, I was able to quickly make progress, and every week at our weekly meeting, I reported my findings to Dr. Dantu, who then guided me on what to do next. By the end of my first semester, I had removed the underlying PoW consensus and had put in the 1st version of our deliberation protocol without the following limitations:

• No fault tolerance
• With only 1 peer (meaning no peer connection)
• No consistency maintained on the deliberated message
• No replication
• None of the deliberation messages were relayed via the two-phase Gossip protocol that Nimiq used.

Part One.Five

After the success of this work, Dr. Dantu and especially my lab seniors told me to write my first paper and start approaching this problem like a researcher, not a developer. I took their advice and started the work. It was tough writing a paper, which is not easy, and I had to put in some really hard hours. Fast forward after submitting my paper to a conference, I could not think for about 2 days. My brain was toast. I had never in my life experienced whatever that was.

Part Two - Address the limitations

This was no easy task. I had to basically undertand the whole process of how peer conection is started, how it is maintained through heartbeats, how data are encoded and relayed between peers through the TCP channel, how data is picked up by the listeners on the other side, how the data are decoded, how the data is authenticated, checked for consistency in the ledger…..I had to figure it all out. And I did, and rather quickly at that. I had a window of about 2 week where I could do focused deep work and I was able to figure all of this out (with the help of consolelog and consoletrace :P, I decided to figure this out on my own and stopped communication with Dr Pascal at the end of my 1st year. This work was done mid 3rd semester). What did I do:

• Modified the underlying gossip protocol to support transferring a deliberation message.
• Added a consistently maintained data state (we call this mempool in blockchain) so that the deliberated messages are consistently maintained in all peers.
• This enabled data consistency and data replication.
• And at the end, check for consensus once deliberation has concluded.

With this, my Proof of Concept for the blockchain side was ready for the next step.

Part Three - Autonomous Deliberation

The goal was not to add autonomous agents into the architecture I built so that the deliberation process could take place autonomously. To do this, I had to have a simple working version where different LLMs interact with one another to solve problems. That was easy, and at the time, LLM was one of the most researched and published areas of CS. The hard part of the hill was already over. Adding these agentic features to the architecture was a breeze. Those 40000 lines of code written by Dr. Pascal and others felt to me as if I had written them. The work was ready. I did my experiments, wrote my 2nd paper, and sent it for review. Fingers crossed.