fuzzymusings

2023, A Year in Review

Anubhab Patnaik — Sun, 31 Dec 2023 00:00:00 GMT

December

The new year begins with a new job and a new hustle. I am looking forward to the next year, and I am excited to see what it has in store for me.

The rollercoaster of the year 2023 is coming to an end. I am glad to be back at home taking a break. Looking back, I am proud of myself for having come this far. This year has been a crucible of growth, and I am grateful for the opportunities that I have had. Life is not a fairy tale, and I have had my fair share of ups and downs. But, with enough grit, effort, and love, you can make it the kind of movie you want it to be.

Here are some of the things that I have learnt this year, and wanted to share with you:

Work harder. Your success is almost directly proportional to the amount of work you put in.
Keep building. There is no end to learning. Growth doesn’t foster in a comfort zone.
Be kinder. You never know what someone is going through.
Save. You never know when you might need it.
Don’t forget to roam around. Travel. See the world. There aren’t enough places to see!

Happy New Year! 🎉

December brought forth a lot of major life changes. As with every good journey, there comes an end. I’ve wrapped up my tenure at StackIt after six fulfilling months. December serves as the last month of my journey at StackIt. I’ve had a great time working at StackIt. This team is the most hard-working, and the most talented team that I have worked with. Leaving StackIt with a heavy heart full of gratitude and memories. Meanwhile, looking forward to the next step in my career.

A couple of interns are also leaving, so we decided to go on a company trip to Gokarna. We had a great time at the beach. We went on a trek, had tons of food, and partied a lot on the beach. The past six months have been extremely fulfilling; made a lot of friends, learned a lot, and built a lot of stuff. Here are the pics of the trip. The journey ended with Go-karting and gaming.

Now, I’m in transition, on the lookout for the next step in my career. The excitement and dread of embarking on a new professional journey is overwhelming. Meanwhile, I have uncovered a new pain point in the developer tooling market, and I’m working on a solution. I am planning to build something of my own.

November

As November came to an end; with merely a month left, I looked at my resolutions for this year and wondered if I even came close to starting them. Contemplating the decisions that I took in these past eleven months, I pondered on how much I had progressed.

This year, I

Graduated College
Got a Job/ started my entrepreneurial journey
Moved to Bangalore; started living away from home
Somehow managed to make money, and send some back home; started paying my bills
Started paying taxes

By the end of this year, I want to have

built more projects
read and written more
become more fit than I was in January
built a solid plan for the next two to three years

Before beginning 2024, I want to have grown to look back at 2023 and be proud of myself; thus, I will be working on myself for the next month.

The festive season in Nov is always a busy time for us Indians. It brings forth long weekends, leaves, and holidays. Corporate folks save up leaves and vacation days to go back home and cherish the season with friends and family. I, too, went back home for this Diwali. We had a Puja at home, and I met my extended family. It was a weekend of fun and a break from my work life. Both my sisters had their birthdays in the beginning of November, and I had to get both of them gifts.

Returning from home is always a challenge. The dreaded steps that I take on mornings when I know I have a flight to catch are the worst. This time too, I did not want to return and with each breath that I took, I wished somehow magically I wouldn’t have to leave my home, and yet I would be employed and earning a living. I had to leave, and with a heavy heart I mustered all courage inside me, and I did. Rio never gets why I have to leave. He is always by my side whenever I am in my home and tries his best to not let me leave my room. There are things that humans do that dogs do not understand, like leaving. I wish I could explain to him that I have to leave, and I will be back soon. While he knows that I will be back someday, he still makes those puppy eyes, unable to speak up or do anything, just looks at me leave. If only I could explain that leaving is a transient inevitability!

The following week was a stressful one. At Stackit, I had a lot of pending tasks on the backlog. While back at home I had to prepare for an important test. The highlight of the week was watching India go into finals in the ICC Men’s Cricket World Cup. Even though I am not a sports fan, looking at my country at the top of the leaderboard, undefeated, making its way to win the finals made me proud.

Tech:

Currently working on building an Nl2SQL engine for StackIt. A platform that can effortlessly translate natural language queries into SQL, automating the entire data extraction and analysis process. The tech behind this would involve vectorizing SQL schemas and using a multi-query engine to find the appropriate schema-embedding section to send to the LLM to generate SQL queries.

At StackIt, we have decided to have a demo pitch round each Saturday. We make presentations to show what we’ve built in the entire week. Inspired by this, a zeal to build my own presentation came rushing. Thus, I started Dough: a rich, modular, command-line tool to generate presentations written in Rust.

Meanwhile, I am planning to pick back up Bee: a command-line bit-torrent client to download torrents written in Rust. I am looking to explore esoteric programming languages and look into the interpreters. Curious about game dev, I am also looking to get my hands dirty with tactical FPS/ open-world games.

Research:

I am diving deeper into the world of AI, prompt engineering and fine-tuning LLMs to convert natural language to SQL queries. The impetus for this exploration stemmed from the shortcomings of an NL2SQL generator at StackIt, prompting a quest for a robust platform automating SQL generation from natural language queries. The model was not able to generate SQL queries for complex questions. Thus, I am trying to understand the prompt engineering behind the entire infrastructure of Lookup AI. Our strategic plan involves developing a platform that can effortlessly translate natural language queries into SQL, automating the entire data extraction and analysis process.

October

October began with a bang. I had a lot of trips planned out. I went to a trip in Dubai! Meanwhile, my childhood friends and I had a week-long trek planned to Kedarnath, UK. Four of us, Mukul, Hritik, Hemant, and I were going to meet in Delhi and then head to Haridwar. Read more about the trip here.

September

Settling down in Bangalore and looking forward to a new, competitive and exciting software engineering life here. The new house is lovely and living with my best friends solves more problems than I anticipated. I am trying to make out time of my schedule to play the guitar more, write more, work on my projects, and also polish up my data structures and algorithms as well. For a good part of my adulthood, I tried to avoid investments and always had my dad take care of them. Now, I have decided to learn more about stocks, investments and the pile of cash surrounding it. I aspire to be physically fit, but my appetite for junk food has spread like wildfire. I am trying to get into a routine and lose a considerable amount of weight before hitting the gym.

My current endeavours encompass a broad spectrum of technical challenges and innovations, ranging from plugin development and deployment optimization to AI-driven solutions that promise to transform the way we interact with data.

Engaged with StackIt, I am working with Google AppScript, React, and Nodejs to build the StackIt Plugin. Our primary focus is on seamlessly integrating a payment infrastructure into the plugin.

Dealing with Google AppScript has proven somewhat challenging. The documentation is not that great and the community is not active. Meanwhile, within the cloud platform, our objective is to establish a clear demarcation between production, pre-production, and development environments for our plugin. We use Docker to create containers for each of us developers and separate virtual machines for each of the environments. Our current hurdle revolves around mapping multiple host ports to corresponding container ports, further complicated by our SSL certificate setup.

To streamline the Node.js and Docker deployment process, I’ve been experimenting with bash scripts, aiming to automate these tasks efficiently. For the React Project, I’ve successfully established a Continuous Deployment (CD) pipeline, facilitating deployments into the Google AppScript environment through Clasp. All of this is being built leveraging Github Actions. I am also working on refactoring the code base to make it more robust, modular and readable.

While working on the AI vertical of StackIt I am planning to invest time to understand the prompt engineering behind the entire infrastructure of Lookup AI. Our strategic plan involves developing a platform that can effortlessly translate natural language queries into SQL, automating the entire data extraction and analysis process.

August

In between all this chaos, A friend visited me in Bangalore. An entire weekend of fun and frolic ensued, as we explored the city and met with friends. It was a much-needed break from the stress of the past few weeks. Two days felt like what was a few hours, and I cherished every moment of it. There are times when I just sit back and wonder how much life has given me and amongst a busy schedule, tough job, less money, and hundreds of whatnots, I have a thousand reasons to be grateful and happy.

Whilst I want to go back to my home, I also love the hustle and bustle of the city and want to build something here. This eternal dilemma is killing me. I am trying to find a balance between the two. Bangalore brings out hope, and discomfort, moulding and shaping me in different forms, challenging me while providing me with growth and success. On the other hand, my home is a place of comfort, love, and familiarity, and provides a sense of belonging.

July

The past few months have been a whirlwind of new experiences for me. Navigating a new city, a fresh job, and an unfamiliar way of life has certainly kept me on my toes. I have been trying to get a hang of the new city, the new job and the new life. I got to attend a lot of networking events in Bangalore.

At StackIt, we meet a lot of startups and enterprises and try to see if our product solves their problem. We went to Chargebee’s Finance and Ops conference, Google IO Connect, and The Magic Ball event. Each of these experiences provided valuable insights into the industry landscape and allowed us to make meaningful connections. Moreover, our recent involvement in YC’s Startup School, focusing specifically on the AI domain, proved to be a significant milestone. This platform served as the launch pad for our AI vertical, marking a successful endeavour in this direction.

However, life threw me a curveball when I fell ill just last month. The diagnosis was a combination of dengue and a stomach ulcer, which necessitated a week-long hiatus to recover back home. My return to Bangalore revealed a turbulent living situation. I had to shift from where I was staying since the rent and overall expenses of the place shot up. There were a lot of unknowns and a ton of expenses that kept on piling up. My roommates did not inform me earlier about this and as soon as I paid the deposit, I was confronted with a daunting list of a shitload of bills that I needed to clear. As I refused to pay, they asked me to find a replacement, or else I would not get back the deposit.

Meanwhile, Srijan encountered his housing predicament. His landlord’s strict no-visitor policy left us with no option but to consider securing a place of our own. Amidst these challenges, my mother stepped in admirably, caring for me during my illness and remaining by my side upon my return to Bangalore.

June

Moving to Bangalore has been tough. The sheer number of people and the traffic is overwhelming. Coming from a place where I had my room, spent a ton of time with my friends, and had a lot of time to myself, it’s been a bit of a challenge to settle down here. I have been trying to get used to the city, and it’s been almost a month since I moved here, and here’s what it’s like.

While adapting to this new environment, at StackIt things have been going great. The product is in a very early stage, so the sheer amount of effort that goes into building the product is immense. The workload is a lot, and it’s difficult to figure out where time passes by. Looking back, I see that it’s already July, and it feels as if I had just joined a few days back!

I have been actively engaged in client-side development using React and Google App Script while waiting for the setup of the development environment. The backend is built in NodeJs. Though I have been enjoying working with React, the client-side development env is wrecked, and it takes a lot of time; to render changes I always need to do a test deployment. The code is written by someone before me, and it’s challenging to understand the workflow, I have been trying to get a hang of it since I joined.

The best part of June is also getting a side gig as a full-stack developer at Asymmetri, working on a PDF generator.

May

As I near the end of my four-not-so-long-year college journey, it feels like the end of an era. Looking back, I am filled with immense gratitude for the incredible experiences and memories that I have garnered throughout my college life. I made lifelong friends, discovered new passions, and grew both personally and professionally. Teasquared is an ode to my alma mater.

Reflecting on my journey, I recently bid adieu to the IEEE Students’ Chapter, where I served as the President (Chairperson) for the past year. Aditya passed on the torch and I did my best to keep it lit. I am proud of the accomplishments of the chapter and the team that I worked with, and I hope that the chapter continues to grow and thrive in the years to come. I still remember the day Saurav sir and I established SWITCH, the official coding club of the college. We wanted to establish a coding community for students by conducting workshops, hackathons, and coding competitions. I wish SWITCH all the best with its new management and hope it continues to thrive. I wanted to accomplish a lot with CBRTL but maybe the timing wasn’t right. Srijan and I started cbrtl, a small, tight-knit group of programmers and open-source sorcerers who like to craft fun projects together and build a community. The Social Media Cell was a fun experience. I worked as a photographer, and I was responsible for capturing the moments and memories of the college. We recently had a hearty farewell organized by the whole SSMC team, and hope to stay connected with each other.

While it is bittersweet to say goodbye to this phase of my life, I am eagerly looking forward to embarking on a new chapter. With my sights set on new horizons, I am excited to see where life takes me and to see what the future holds. I am exploring my options and scouring for opportunities. I intend to work with the biggest tech companies, building products and creating differences.

I got an internship at StackIt. I intend to work with web applications and set up CI/CD and data pipelines.

“At StackIt, we wish to take Spreadsheets into a new era. We are building the next-generation spreadsheet automation platform that will empower 1 billion+ business users to use spreadsheets as their business OS. StackIt is a Google Sheets Editor Plugin. Business teams can rely on StackIt to pull data from popular SaaS tools & internal databases like Chargebee, PostgreSQL, MySQL, etc regularly on spreadsheets. They can further analyze and build workflows & dashboards on top of it using StackIt.”

April

I hosted Git Groove: Getting into the rhythm of version control with Git & GitHub, with the UnStop Chapter of SIT, BBS and it was a huge success. We are planning to host a more advanced session on Git and GitHub shortly. There’s also a web development workshop coming up.

Meanwhile, at IEEE, we arranged a talk show that focused on getting to know IEEE and its benefits. The IEEE Students Chapter is dedicated to promoting knowledge and understanding of engineering.

Lately, I’ve been working on a custom bit-torrent client to download files and movies based on recommendations from my movie recommendation system and a movie rating prediction system. The goal is to integrate both these systems to work with this bit-torrent client I have been building to download movies based on recommendations.

I recently visited Bangalore and met with my friends; to explore and pursue a new idea. We had a great time, and I look forward to meeting them again. My primary priority remains the same, to work with one of the top tech companies and work on projects I am passionate about. While I go and hunt, Srijan and I have planned to start something of our own! The egg has just been laid, and we have a lot of figuring out to do, but I am excited about it.

March

March had mid-semester exams in stock for me. I thought I wouldn’t pull through and fail miserably. (Chill. That didn’t happen xD). But as I geared towards preparing for the exams, desperately trying to collect notes, a sense of responsibility dawned upon me. A friend reminded me that we were supposed to build the half-baked project together that makes notes and academic materials accessible for free and I started on the first day of my exam and completed it Resoc on the last day of the exam. (Funny how I managed to find a way not to study enough xD). You can read more about it here. We acquired a user base of 96 with an average engagement time of 3m14s and more than 2980 reads within a week of launch! We are looking for active contributors interested in contributing their notes.

With the end of the semester approaching, I am looking forward to a much-needed break. However, this impending respite also brings with it the realization that my time in college, particularly with my friends, is dwindling. My mind races back to those initial days when I struggled to introduce myself to seniors and make friends. Those moments, in retrospect, were the extent of my worries back then!

Today, the landscape of my concerns has transformed exponentially. Each morning, as I wake up, a whirlwind of thoughts engulfs my mind. I become aware that there is an overwhelming number of challenges and dilemmas that I may never fully resolve. Now, standing at the crossroads between the present and the future, I’m confronted with the weight of responsibilities and uncertainties. The path to adulthood feels daunting, and the magnitude of the challenges can be overwhelming.

As the days of college slip away, I’m determined to make the most of the time I have left. I cherish the friendships I’ve formed and know that they may change but will always hold a special place in my heart.

Furthermore, as I gear up to graduate this year, I am actively scouring the web for compelling summer internship opportunities, and well, jobs.

February

I am thrilled to have bagged the Best Delegate award in the XIMUN 2023, the annual Model United Nations conference hosted by XIM University, with my go-to co-delegate, Avinash. Our team represented Pakistan in the Disarmament and International Security Committee (DISEC). We decided to go with Pakistan because representing any other nation or a P5/ NATO nation is relatively more straightforward because there are fewer fingers pointed at you and Pakistan presented a unique challenge due to its reputation for alleged notorious activities. Overall, it was a satisfying victory, and I am grateful for the opportunity to have participated.

I am modifying zuzu to port my blog (written in Hugo) to zuzu. This entire site and the blog are now built using zuzu. Zuzu is a custom static site generator written in JavaScript. It includes static file compilation, dynamic search, and an RSS feed generator. You can find the source code here. Currently, it is in a very early stage of development, and it is designed to work like a basic static site generator. But it can be modified to cater to your needs easily.

January

My time as a full-stack engineering intern at Squbix Digital had to come to an end. I’m grateful for the opportunity. During this stint, I was tasked with building web and mobile apps to integrate with the spinal blockchain. My work included but was not limited to, TypeScript, NodeJs, ReactJs, React Native, Substrate, and Rust which was primarily focused on Web-3 dev; cryptocurrencies, decentralized applications, blockchains, and NFTs. I was also responsible for refactoring React-Native applications with better UI, building offline consistent storage services, push notifications, and an internal ERP system to monitor the attendance and tasks of employees, modifying the existing NodeJs code configuring optional parameters to switch between blockchains, refactoring the JS-based SDK to TypeScript. We also had to build a browser extension, and a PWA for the wallet-to-wallet transactions. The challenging part was the Polkadtot chain, where I messed up the existing DID (identity) pallet using Rust and Substrate to store ID information in the blockchain.

The other part of the month was an exhilarating trip to two of India’s most bustling cities, Mumbai and New Delhi. The highlight of my visit was attending Mood Indigo 2023, the annual cultural extravaganza hosted by IIT Bombay. The entire trip and the experience left me in awe- exploring old forts, indulging in street food, and immersing myself in the vibrant culture of these cities.

2024, A Year in Review

Anubhab Patnaik — Tue, 31 Dec 2024 00:00:00 GMT

December

2024 comes to an end. A year full of growth. 2024 has been a year of immense growth for me, both personally and professionally. I embarked on numerous journeys, traveled to a lot of new places, so much so that I moved from India to the US. Mentally exhausting, but extremely satisfying. New York City is as beautiful as ever. The streets are filled with lights, and the air is filled with the sound of Christmas carols. The city is bustling with magic, love and happiness, and the festive season is in full swing. With the onset of 2025, I plan on taking a break from everything and visiting home, back in Bhubaneswar.

Ever tried to convert a PNG to SVG? Here’s why it is difficult to achieve this: the two formats fundamentally differ in how they represent images. PNG images are pixel-based, meaning they store visual information as a grid of colored pixels, whereas SVG images are path-based, relying on mathematical equations to describe shapes, lines, and curves. The challenge lies in translating the discrete, resolution-dependent data of a PNG into smooth, resolution-independent vector paths.

I was experimenting with pixel-art; trying to convert PNG and SVG formats to pixel art and stumbled across this issue above. To solve this, I am spending the next couple of weeks working on a application of Fourier series, a mathematical tool for approximating complex shapes with sums of sine and cosine functions. A Fourier series represents a periodic function as a sum of sine and cosine waves, each with specific frequencies, amplitudes, and phases, allowing complex patterns to be broken into simpler components. This might not be the best, most efficient solution, but a fun, educational exercise nonetheless.

Meanwhile, here’s a small pixel-art generator for SVGs and PNGs written in Rust: pixlr

Yatch, the RISCV simulator, is shaping up well. The forward pass and stalling work well with the current nop setup and bubble implementation. I am currently focused on fixing minor issues in the hazard detection pipeline and am yet to implement multiplexers for forwarding, branch prediction, and control mechanisms.

November

I finally built that 32-bit machine code simulator for RISCV in C++, Yatch which I was supposed to, do for Hacktoberfest. It took me a longer time due to my mid-semester in between. It supports a realistic five-stage pipeline for processing multiple instructions concurrently with measures for avoiding control and data hazards. It is currently capable of executing RV32I instructions, and I am planning to extend it to support RV32M, RV32A, and RV32F instructions. The project is still in its early stages, and I am looking for contributors. If you are interested in contributing, feel free to reach out to me.

Debugging Yatch inspired me to build a machine code decoder to analyze RV32I instructions and translate them to assembly. A standalone version is in the works which would be capable of encoding assembly to machine code as well. Check it out here: Barney.

Researching more on designing compilers and automata theory, I came across Conway’s Game of Life, a fascinating 0-player cellular automaton that follows simple rules to create complex patterns and is turning complete. Here’s my implementation of the Game of Life: Conway’s Game of Life. It’s exciting to see how the four rules are capable of creating such complex patterns, such that you can build a computer using them.

Back home, November ushers in the festive season, where the celebrations typically begin in September- October with Ganesh Puja, Navratri, Durga Puja, and Dussehra leading up to Diwali in November. Now, I am used to a different energy of festivities and celebrations. I lived my whole life in central-eastern India, and here in Odisha, West Bengal, and Jharkhand, the Navratri- Durga puja celebrations are the grandest, leading up to Diwali and Chhath Puja. The streets are filled with lights, and the air is filled with the sound of crackers. The houses are decorated with lights, and the markets are filled with people buying clothes, sweets, and gifts. We roam around days and nights, tuitions are shut down, school has a different energy, and the entire city is filled with love and happiniess.

Diwali is usually spent in phases. The first phase is when Diwali hasn’t begun, but the sale of crackers has started, and we cannot wait and get a bunch. We spend the next two days bursting crackers, and the challenge is to save enough to celebrate properly on the main Diwali Day. The Diwali Day is filled with love, laughter and happiness. New clothes, sweets, and family get-togethers are musts. The next day is spent visiting friends, bursting crackers with family, and playing cards. Now that I am not home, I feel that I am old enough to be let into the room that elders lock because they drink and gamble. I miss the fun, the laughter, the food, and the love.

Dealing with post-Diwali blues is morbid. The house is a mess, the lights are off, the sweets are over, and the crackers are burnt. The house is empty, and the silence is deafening. The only thing that remains is the memories of the fun we had and the love we shared.

Two months later, in December, we look back at the memories we’ve made, surprised at how quickly another year has gone by. I still sometimes do not fully understand how have I managed to get by, this year.

It’s hard not being at home. New York is lovely and feels just like home, but it’s not. To you, alone, in a different place, not being able to come home on Diwali, I wish it gets better. Happy Diwali, everyone!

October

Halloween is here, and fall in NYC is as beautiful as ever. The leaves are changing colours, and the days are getting cooler. Sunny days are the best. I’m adapting to the colder weather, the daily commute, and the steady stream of assignments. The workload is getting tougher, and my motivation to study is wearing thin. October has been full of learning and growth. I’m back to grinding on Leetcode, polishing my skills and trying to stay consistent. I’ve started cooking daily, adjusted my lifestyle, focused on eating healthier, and even lost 5 kg in a month through consistent workouts.

For the Hacktober fest, I wanted to take up Yatch: a machine code interpreter for RISC-V in Python/C++. The aim here is to learn more about compilers, the workings of CPUs, and computer systems architecture. This a great project to get started with if you’re keen to learn about low-level programming. I’d love to collaborate with others who share similar interests.

The academic pressure was so huge that I had zero time to take out from my schedule to work on any of these. I was heavily occupied with assignments, Leetcode practice, and staying on top of my fitness goals. I aim to wrap up these projects by the first week of November.

October’s highlight? Spending time with my cousin, a serial entrepreneur with multiple outlets of a popular mobile carrier provider here in Manhattan. Half the month was a first-hand crash course in consumer business as I watched him engage customers, close sales, and manage operations. I learned more about sales, customer acquisition and service than any book or course could have taught me.

I saw what makes customers want to spend, what makes them ick, and what they’re usually willing to pay. Confidence is essential. If they have a sniff that they are being charged extra, you’re done. You need smooth communication skills. I also realized how empathy can drive sales, and that upselling is a skill. Selling a $300 item for something valued at $100 requires finesse. People here often don’t negotiate; they prefer to pay for convenience and quality without haggling. India is a different ballgame. People there are more price-sensitive. Network providers cannot take the same approach in India as they do here.

Here’s the thing about the US: people are willing to pay for convenience. They don’t mind paying extra for a service that makes their life easier. In fact, they want to pay more for the latest iPhone, which has the best cameras, the best display, and all the new AI features, etc. India is entirely different; people there are more price-sensitive. They want the best deal and the best price, and they’re willing to haggle for it.

Here is a better understanding of how this business model works: iPhone on the house

This has given me insane insights into what it takes to run a consumer business, and how to sell. I’m still uncertain about how well these lessons will translate to tech, but I’m excited to try them out.

September

Settling in here, in New York City, has been fun and growthful. The worst part of staying away from India is not having access to a myriad of cheap labour. I have to do everything myself now. I must cook, clean, do laundry, commute using public transport, and manage my finances until I find some form of employment.

Living in Jersey City gives me access to bigger, wider rooms with amazing skyline views, and a lot of greenery. The rent is cheaper, and the cost of living is lower. Jersey City is very clean and quiet, away from the hustle and bustle of NYC, and has a lot of parks and greenery. I stay on the bank of the Hudson River, and the view is amazing. I can see the entire skyline of Manhattan from my window. The state taxes are lower, and access to Indian communities is easier. There are a LOT of Indians staying in New Jersey, and I can find Indian groceries and restaurants easily.

The only downside is that I have to take a subway to reach NYC, and then transfer to another subway to Brooklyn. Midtown Manhattan is a 5-minute ride across the river, and Brooklyn is a 30-minute subway ride. The commute can be a bit overwhelming at times. The peace, the size of my room for the rent, the views from the window, and the facilities in the locality make up for it.

September begins with my first semester at NYU. The culture here is very diverse. The classes are long, the assignments are overwhelming, and the professors are very knowledgeable. Most are part-time lecturers with a full-time job at multi-national tech companies. Although, there is an “accent” problem; it is difficult to understand some of them at times, but it is a learning curve.

I have taken up three courses this semester: Data Structures and Algorithms(the same old kingmaker terrorizing SEs all across the world xD), Computer Systems Architecture( an advanced version of COA from bachelor), and Internet Architecture and Protocols( focusing on Internet architecture from CN in bachelors). The subjects are interesting but the assignment overload is intense.

Meanwhile, I am planning to restart a couple of projects that align with the subjects I have taken up, the distributed file system, and the compiler.

Looking forward to an amazing Semester here at NYU, New York City.

August

Moving to a new country is tough. The past couple of weeks have been really busy and exciting; arranging funds, exploring scholarships, looking for housing, and overall planning the move. Rachna and I are leaving together for NY, and this makes the transition a little bit easier. The other difficult part of living this dream is leaving my family and friends behind. I have been feeling extremely homesick since I arrived here, and I miss my friends and family a lot.

July

Three biggest updates:

I got accepted into NYU( New York University ) for Masters in Computer Engineering in the Tandon School of Engineering. I am moving to NYC!
Back to the startup life; building datingai.pro, your perfect wingman.
With all good things, comes an end. I am leaving RadiusAI, and India.

I am back to the startup drill. Staying up late, shipping features, building, failing, talking to customers, discussing our GTM strategy, and building the product, have been the highlights of the past month. I am excited to be a part of the founding team at datingai.pro. Including me, there are five of us in the team now.

A sad part of all of this is leaving RadiusAI. I have been with the company for seven months and have loved it here. In the end, difficult decisions have to be taken, and while this was an amazing learning experience and a great place for growth, it’s time for me to leave, take flight, and build my own nest.

I am going to miss my team and the office. The weekend get-togethers at pubs and breweries, and me coaxing everyone to come out for lunch and play carrom have been the highlights of my time here. From GitHub actions deployment failures and optimising memory in my Rust applications to compiling cross-platform binaries and multi-threaded applications and fixing Kafka and RedPanda issues, I have learnt and grown a lot as a software engineer. I will be forever grateful to Rachna and indebted to Ram for getting me into the team and making this happen.

To the team, I will miss you guys, and I hope we cross paths again. Here’s to the good times and the memories we made. 🥂!

The end of June and the beginning of this month was an extremely emotional goodbye, as:

I met with my childhood best friends from all phases of my life, toghether, had an amazing weekend in Mumbai, and bid adeiu to them. It was a nostalgia trip, and it felt very content to see them become friends.

We reminisced about our school days, gossiped about who dated whom, and laughed about the stupid things we and our teachers used to do. We talked about our JEE preparation days, locked our home, unable to fous with all the pressure surmounting us and finally giving up and buying a gaming console instead of shutting down TV. Our college days, and how we used to bunk classes, and go to the beach, and how we used to get drunk and watch movies.

I have been friends with Ankit since 2012 now, with Vishnu since 2016, and with Abinash since 2019 now. Getting together, drinking and talking about our lives, our dreams, and our future, was an extremely heartfelt and emotional experience. Goodbyes are tough. This is the best farewell gift I could have ever asked for; them, just being there, and being my friends.
I went to Goa with my college friends, Tushar and Mahak, and it was amazing! It was a road trip from Bangalore, and it took us 10-11 hours to reach there. We stayed at a AirBnb, spent three and a half amazing days there before returning back to Bangalore.

The first day was tiring, we just hung out in the Bnb room, had amazing seafood in a beach shacks and just sat and chilled on the beach. The second day was exploring North, and Old Goa. We webt to forts, beaches, lighthouses, trekked, and found cliffs from where we could see the entire Goa, and in the evening, we explored the old city, monuments and architecture. The third day was spent in South Goa, exploring the rocky beaches, hidden beaches, and the best sunsets. We kayaked on the backwaters, and had lunches in beach shacks.

The last day was churches, and shopping, and we returned back to Bangalore. We had amazing food, and drinks, and we danced, and sang, and laughed, and had the best time of our lives.
I went on a major road trip with my dad from Bangalore to Bhubaneswar. We travelled through 1500 kms, and it took us a day and a half with a small halt near Nellore. I was shifting, and I returned home with a bunch of stuff that I wanted to keep. The most important on my bucket list was attending Ratha Jaatra before leaving, and I also had to sell my car. I had to meet my family, and friends, and say goodbye to them. I had to pack, and plan, and prepare for the move. I had to get my visa, and my tickets, and my insurance, and my housing, and my bank accounts, and my sim cards, and my luggage, and my documents, and everything.
The entire shifting from Bangalore journey ends with me and mom in a TN tour. We visited Pondicherry, Rameswaram, Madurai and other places.

June and July had me cover entire western to eastern India, from beaches to ghats, the road trips were dreamy, magical, and I would cherish them for a lifetime.

June

May was hectic. I turned 24, went back to home for a week, and spent an amazing time with family and friends. I am back in Bangalore now, and life is busy.

Back in Bangalore, I finally got to building my own budget gaming PC with Akash, a senior from office. Coming from a PS5, a gaming PC did not make sense initially. I wanted to play competitive FPS( first-person shooting ) games with my mates but Valorant and CS2 are not cross-play compatible or present on PS, yet. A minimum budget windows CPU build seemed apt.

I went with the AMD Ryzen 5 3400G with Radeon RX Vega 11 because it has decent benchmarks and has a built in GPU and I did not want to spend on an additional GPU now. This CPU is powered by two 8GB DDR4 RAM and the xmp profile set in BIOS to make them run at 1600 Mhz( max capacity ) each. The build is powered by a Gigabyte B450M DS3H V2 motherboard, without a wireless module, and a MSI cabinet with 6 fans. I am yet to achieve the maximum performance out of this build, and will update here soon.

I am looking to hire a SE intern at my office, RadiusAI. Feel free to reach out if you are interested.

My current endeavours keep me occupied, and don’t leave me with much time to work on personal projects. I am currently working on a couple of projects at RadiusAI. These include building a developer tooling platform in Python for RadiusAI, and a multi-process simulator in Rust to read, sync simulate and handle messages from Kafka and RedPanda. The last project is insanely complex and exciting.

May

My family visiting me returned back home. The most dreaded feeling is when you have to say goodbye. I have always been a lot attached, and it was painful. Before leaving, we decided to get matching tattoos! Here are mama and baby dinausors on our wrists.

April

I bid my best friend a final goodbye as he left Bangalore permanently. He decided to quit his job and follow his passion. The current economic climate is not conducive to his interests, and the job market is extremely rough. A sense of this weird melancholy prevails over me. While I applaud his courage, a part of me wants him to stay and hunt for jobs here. I am going to miss our late-night conversations, our shared interests, and our shared dreams. We started off watching stand-up comedy in the first year of college. From college politics and friendships to getting drunk and watching Rockstar. From walking Rio to getting high and watching Batman. From internships and long car rides to getting jobs and going on trips to Mumbai, Mangalore, Pondicherry, and where the hell not. We have been through a lot together. I am going to miss him a lot. Before leaving for the airport we decided to get something together and have one last meal in Bangalore; and so we went into the Apple store to get something together, and for the restaurant I chose KFC considering that he is a vegan xD. We plan on getting the WWE2k24 and playing it together. A blue summer awaits.

April is all about spending time with my family visiting me in Bangalore. We had to visit some collges, thus we had to travel a lot. A fast-paced, exciting adventure to Gujrat and Uttarakhand ends this fortnight.

We went to Ahmedabad, Dwarka, Somnath, Rishikesh, Haridwar, and Dehradun. The trip was a mix of adventure, culture, and spirituality. The best parts were the river rafting, and Ganga Aarti in Rishikesh, and the visit to the old city, Dwarka, the residence of Lord Krishna. Back in bangalore, looking forward to the same old monotony.

I am not planning to build anything new as of yet. Work consumes most of my time. Mostly invested in research, I spend time exploring business, product, and tech ideas. The ultimate goal is to build something bigger, unique, and sell it, or build a company around it. Here’s an amazing article that I recetly came across by Paul Graham about how Reddit got started. He says, “Reddit the site (and now app) is such a fundamentally useful thing that it’s almost unkillable.”. I am looking for something like that. Something that is fundamentally useful, and unkillable.

March

An hectic beginning to the month; I just returned, and had a terrific week back at home. All of my best friends were back, together, and we meandered through familiar haunts, roaming around, exploring places, and restaurants, and talking about our current lives. The weekend after that was spent in Pondicherry, with Abinash. We explore bakeries, french architecture, Auroville, the beach, and the city. After a week-long hiatus with friends and family, and an excruciatingly tiring trip to Pondi, I am back in Bangalore, looking forward to a productive month.

Not planning on taking up much work, I have thought of taking an hour of my day to figure out where this is all going. March is supposed to be an interlude, a time to reflect and recharge. I have long-term goals, and to be able to accomplish them, I need to be more disciplined and focused. The path must be streamlined. This daily routine will help me to stay on track and keep my goals in sight. This month would be spent planning out the next four odd years. My short-term goals would be to focus on my fitness journey and improve my writing. Writing has always been a passion of mine, serving as a conduit for connecting with others and sharing my insights. Lately, I’ve been particularly prolific, and I have been writing a lot.

March ends exciting. I finished up with NiceDear, a dynamic open-source avatar generator that crafts unique avatars based on user input. Looking to upgrade my desk setup, I finally made the switch to a fully customisable mechanical keyboard, and an ergonomic mouse. I initially planned on going with linear switches, but I ended up with tactile ones. They are pre-lubed, and the PCB is covered with a layer of foam. I am using the fully hot-swapable Keychron K2 Pro, with banana switches, aluminium casing, south-facing RGB lights, and a custom keycap set. The mouse is the Logitech MX Master 3s Mac, white. It has an 8,000 DPI optical sensor that can track on virtually any surface, including glass. I have mapped the horizontal scroll-wheel, and the back, and forward buttons to custom schortcuts. The next step would be upgrading my desk mat.

Feb

I went on a trip to Mangalore with Abinash for a night. I had been occupied with a lot of things lately and this was a much-needed escape. Back in Bangalore life is slow and boring. A few friends came over on the weekend and we had a ton of fun. This new place at HSR Layout, Plan B, is my go-to hangout destination. They serve the best damn chicken wings in town. Looking towards to chilling out with my friends and family, back home this last week.

Here’s how Dough is shaping up:

Here’s everything about Dough

If you’re eager to dive into the world of Rust and looking for a project to contribute to, Dough presents an exciting opportunity. Here’s a breakdown of what’s currently not working and areas that could benefit from your expertise:

Fix scrolling issue in highlight mode:
- bug Over Scroll in infinite scrolling
- feat Skip empty lines in highlight mode
bug custom aligner adds empty lines after text-block alignment
feat. Hot Module Reload
feat. Add support for the maximum width and height of the terminal. (Write a word wrapper)
feat. Add comprehensive support for common Markdown elements.
- feat. Enhance rendering for complex markdown elements like links within headings or lists, blockquotes, and tables.

I am looking for contributions from peers regarding the pending issues, making this a more robust open-source project.

At Radius AI I am involved in building an async uptime monitoring service using Rust, and also a concurrent heartbeat service in Python. I will update this page with more details soon.

Got a new idea about a content summarization and accessibility tool. Still in the early stages of the idea, I might share more details soon. Mostly, it would be:

content aggregation; recommendation engine
search engine
bookmarks, and TL;DR, summarization

Jan

Happy New Year, muchachos! I hope you had a good one. I just returned to Bangalore after a much-needed break in my hometown. Leaving home and returning to the city was a bit of a bummer, but such is life! The dreaded omicron variant is wreaking havoc in the city. I am starting a new career at RadiusAI as a Software Engineer, and I am pretty stoked :D

Here’s an improved version of Llama Index’s sub-querying engine used to generate SQL from Natural Language: Neak.

Coming onto Dough: a rich, modular, and customisable content generator, crafted in Rust, here’s everything you need to know. This is a breakdown of the tasks I was working on:

v2:

Improving the rendering engine:
- ~~Add a refresh feature while rendering slides~~
  - Hot Module Reload( FIX )
- Add support for rendering nested syntax
- Add support for the maximum width and height of the terminal. Write a word wrapper.
- ~~Address the color storage issue for multiline elements, ensuring ANSI escape sequences are properly stripped: Refine color correction post-alignment~~
- Enhance rendering for complex markdown elements like links within headings or lists.
  - ~~lists.~~
  - blockquotes.
- Provide comprehensive support for common Markdown elements.
  - ~~Improve the rendering of thematic breaks~~
- ~~Improve the design language.~~
- Image support for terminals with image capabilities is pending. (Kitty, iTerm2, etc.)
~~Syntax Highlighting in code blocks~~
- ~~Improve the performance of syntax highlighting. The current implementation is CPU intensive. Use a different library for syntax highlighting, or parallel threads to improve performance.~~
~~Custom text alignment: A regex match for individual text alignment~~
- ~~Improve the alignment of segments of text.~~
~~Implement running code blocks on separate threads and displaying results in the current console.~~

2023

2025, A Year in Review

Anubhab Patnaik — Tue, 23 Dec 2025 00:00:00 GMT

December

It’s that time of the year again. A whole year went by? This one was full of growth, learning, and perseverance. Mostly quiet, unlike 2024. This year was fewer friends and family, more work and self-discovery. The nomadic life, the adventure continues.

Highlight would have to be the summer this year. Spent May and June winning World Builder Residency at Edge Esmeralda and SF, California. The experience was surreal, to say the least. Meeting amazing founders, builders, and creators from all over the world, exchanging ideas, and building cool stuff in the beautiful vineyards of Healdsburg is where I want my life to be heading. Next up would be Seoul, for another month, in August. South Korea for a month was a life-changing experience. Exploring Seoul, working with an amazing team at Authentic, and experiencing a new culture was refreshing.

My formal education for this lifetime seems to have come to an end, and I couldn’t be happier about it. Graduated this December with a major in Computer Engineering from NYU Tandon. Also, started my own company :) (More on that soon)

2026 looks promising and full of hope. Taking some time off from this site, will be back in Jan! Wishing you a merry Christmas, and a Happy New Year. Happy Holidays!

November

Mostly occupied in work and wrapping up college work for the semester. New York is chilly now, with temperatures ranging from 5 to 15 C. The city is beautiful in the fall, with the leaves changing colours and the air crisp and cool. The most annoying thing now is going back to standard time from daylight saving time.

A couple of projects are pending. My coursework requirements include a few projects; an application on Fourier-series analysis: transforming signals from time-domain to frequency domain and vice-versa, a small GPU Kernel for LLM inference, and an algorithmic trading bot and stock pricing option pricing using Monte Carlo simulations. Expecting to finish these in the next couple of weeks and write more soon. Authentic is going well. Launched, live on the App Store now.

October 🎃

This weekend was exhausting. Participated in a 24-hour hackathon, NASA Space Apps Challenge, and built Lighthouse - an air quality monitoring app using NASA’s open APIs and some ML magic.

The task was pretty laid out, straightforward; NASA’s site mentions on the page exactly what to do - build an air quality monitoring app that caters to different user groups. I remember starting to work on it on a Saturday morning, and now it is early Monday morning, just about submitted it, tired but ready to face Monday. Standups, meetings, sprint planning, and all that jazz. Also, some college work to do. (2 more months to graduation!)

The challenge for me here was not the tech - a React-native + Flask app, deployed on Railway and TestFlight. The hard work was the product. How do I sell this? How do I compete with years of polished app experiences/ ecosystem tie-ups, alert mechanisms for Wildfire alerts, heavy thunderstorm warnings, umbrella suggestions, etc, which were all extremely doable, but what could be my moat? Spent some time thinking about product development and PMF.

The Oct - Nov period is usually the most happening time of the year for me. Growing up in Eastern India, Durga Puja/Dussehra marks the onset of the festive season. The city is decorated with lights, and the atmosphere is vibrant. We visit friends and family, do not bother about getting up and going to college/ work the next day, and just enjoy the food and celebrations. Most weeks have some holiday going on, Diwali not far away. All of us living in other parts of the country come back home, and we all meet up, eat out, and have fun. October looks like I’ll be living in nostalgia for a while now. At times, I wish I could just leave everything behind and go back to India.

September

Authentic is going well and is almost ready for launch. The app is now a functional, Instagram-story-like app with ephemeral posts. Current versions focus on perfecting the iOS builds before moving on to Android. I am currently working on optimising the runtime performance of the app, reducing the bundle size, mostly improving the overall user experience - better error handling, reducing response times in posting, improving UI feedback, etc. The aim here is to make it ready for App Store submission. The app is invite-only for now, and we are working on building a waitlist for the app. Email me here if you want in.

The last week of August was all about helping friends pack, move, settle into new routines and preparing for the upcoming fall semester. Back to school now. The last ride; graduating this December.

August

August 16 marks one whole year of my life in the US. Feels happy, nostalgic and content; eudaimonic in ways, looking back at all that I have achieved so far in this past year, having made a whole year alone as an adult in a foreign land. Celebrated last year’s Independence Day with a couple of friends from work and college, playing paintball, eating out and watching patriotic movies. This year, on 15th August, spent the day roaming around in scorching 35 degrees in NY with friends, and sat down by the river to look at my tricolour on the Empire State and World Trade Centre. Looking forward to another year.

New York City celebrating India's 79th Independence Day

Leaving for New York in mid-August. Happy to be finally back, properly, but I will miss Seoul. The last time I was living in New York was back in April. These four months have been a whirlwind of experiences, from Healdsburg to Seoul, and now back to New York.

Life in Seoul is amazing. Seoul is vibrant, rich in culture, and has a fantastic food scene. I spend most of my time working on Authentic and remaining focused on exploring the city. The weather is warm, with temperatures ranging from 28 to 40 degrees Celsius.

Built on top of Next.js & Vercel (Migrating to Express + Railway), and React Native, Authentic is now live on the testflights on app stores. Think of it as a privacy-focused, ephemeral social media app- a Snapchat/ Instagram of sorts without ads or doomscrolling. The primary motivation behind the app is to create a non-infinite space where people can share their thoughts and experiences without having to apply filters to fit in or worrying about the permanence of their posts. We fight doomscrolling, ads targeting, and the constant pressure to curate a perfect online persona.

Here’s a fun little hack that I built for the Authentic Office in Korea: blink all the lights in the office on a PR merge to celebrate a new feature shipment. So, we had these ‘Sunset Lamps’ that would change colours and create a nice ambience during our late-night coding sessions. They operated either manually using the physical switch or through their proprietary app. The actual challenge here was to figure out the exact set of commands used for each action.

I installed a Bluetooth profile on the iOS device and used the packet logger on my Mac to track all the packets being sent out over a time frame of 10 seconds. Turns out some devices advertise manufacturer-specific data on a new connection. This helped me get the UUIDs of the devices. So, I spammed different light options in the app within ~10 seconds and added filters in the packet logger using the manufacturer-specific data and the time window to find a bunch of commands being sent out to one specific UUID that I had identified. Once done, created a flask server with bleak to scan for devices, match the UUIDs, connect, and brute-forced all recorded commands, until one command worked—the light turned off. Then GPT-4o helped me flip the hex command into the “ON” version. Success.

The rest of it was simple; a Github webhook call to the Flask server via ngrok, and a trigger that blinked the lights thrice on a successful merge of a feature branch. Later, I added a cron job to periodically check the status of the lights and ensure they were responsive. The final touch was a Siri Shortcut on all our laptops that just did a GET call to the Flask server via ngrok tunnel. Anyone could yell: “Hey Siri, Authentic Party!” → instant disco mode.

Fun times.

The office and disco lights

Office and photobooth

We ultimately decided to build the app using React Native. Choosing a mobile framework just makes more sense as a developer and from a UX perspective. The first week of August would be spent doing Coffee Chats with end users, testing and gathering feedback on the app on the alpha build. The app will be out on beta soon. Migrating from Next.js to React Native was a challenge, but a week of toil and badgering Claude 4 Opus APIs and exhaustion later, we have a working app. The app, for all intents and purposes, is now a cute-looking, functional app that works on both iOS and Android. Excited to share more soon.

July

A lot of updates this month. The h011yw00d internship comes to an end. Had an amazing experience in California building a user-centric social media app with tens of thousands of users. CA led me to some other awesome teams working in similar spaces. Thus, a new life update: spending the summer in Seoul, working for Authentic as a mobile software engineer. My aim here is to take the web-app mobile, building a Capacitor app based on the Next.js app and ship it on the app stores as the first MVP version.

Relocated to Seoul, South Korea, for a month. Authentic is currently operating out of Seoul. Excited to be here, exploring the city, and working with an amazing team of engineers and designers. The culture is vibrant, the food is delicious, and the people are friendly. Looking forward to experiencing the local culture and learning more about the tech scene here.

The worst part of all of this is the jet lag. I have been struggling with it for the past few months now. In the last 2 months, I have travelled across 3 continents, and the time zone changes have been brutal- more than 4 different time zones in the last 2 months. Still trying to adjust to the new time zone here in Seoul, which is 3.5 hours ahead of India, 13 hours ahead of New York, and 16 hours ahead of California. Hoping that spending some time in the sun and getting some fresh air will help adjust. The curse of living the Jajabara (nomadic) life! Crazy how life has always been, for as long as I can remember now. Twenty-five years, packing up and moving to a new place every few years, and now, months. Will write more about this in a separate post.

July starts with a trip back home to India until the fall. Ratha Jaatra, the chariot festival in Puri, is the one event I try hard to make it to every year.

Taking a break from the project-building phase was a mindful call. I spend most of my energy on actual work, focusing on my internships. Currently working with distributed computing - scaling, maintaining, deploying, and managing the video generation app at h011yw00d. The aim would be to keep hunting for technical founding staff/ founding engineer roles for when I graduate, which will probably be at the end of this semester/ year. Excited for what’s next.

June

Won the World Builder Residency! :) LFG

Worldcoin builder residency, summer, Edge Esmeralda, 2025

Summer in California is beautiful. Healdsburg is a small town in Sonoma County, known for its picturesque vineyards and wineries. The weather is warm, with temperatures ranging from 25 to 30 degrees Celsius. The town has a charming vibe with boutique shops, restaurants, and cafes. Currently, it’s filled with tourists/ people attending Edge City, a tech pop-up village, which is more like a tech summer camp, where people can come together to share ideas and collaborate on projects. I am part of the World Residency program, where we build and deploy a mini app that runs on the World ecosystem.

Now, while I am here, I did decide to ship fireside, a decentralised encrypted chat app I built some years ago, on worldcoin. I was anyway working on shipping h011yw00d, thought I might as well try to ship something of my own. This blew up! Acquired 500 users in a day and was in the top 10% of the apps without any marketing.

Here are the metrics after a day of launch :) -

The rest of the time, when I am not working, I spend exploring California, visiting San Francisco, Redwood National Park, and the beautiful beaches along the coast.

San Francisco is a vibrant, beautiful city, known for its diverse culture, tech scene, and absolutely stunning views. The weather is mild/ cold, with temperatures ranging from 12 to 20 degrees Celsius. California has microclimates, so the weather can vary significantly from one part of the city to another. I halted in Presidio for a couple of days, a Bay Area neighbourhood, also a former naval base turned into a national park. Worked out of the House of Web3, with beautiful views of the Golden Gate Bridge and the bay, with hiking trails and picnic areas. Presidio also has this amazing trail, Lands End, which offers breathtaking views of the Pacific Ocean from the cliffs. This is hands down my favourite place in SF, and my favourite hike so far.

Scattered clouds over San Francisco, hiking in the redwoods, and gazing at the sun over the Pacific from Lands End

The city has a rich cultural scene, with museums, galleries, theatres, and amazing culinary experiences. The food here is probably the best I have had in the US so far. I attended a few meetups and events and got to meet some amazing founders. SF inspires me to move here someday. If I ever do decide to move out of New York, I think SF would be the place.

May

Moving to SF for the summer. Summer internship as an AI Research Engineer at an AI/Web3 startup, h011yw00d - an AI agent that generates autonomous cinematic videos, currently active on Twitter. My role involves working on the apps that run on this AI engine - the underlying distributed computing infrastructure, deploying and maintaining it.

My speculations about the Web3 world aside, and the fact that crypto is 99% a scam, innovation and profitability are two separate things. Businesses don’t need useful technology to make money. A few are financially successful businesses, although built on technically questionable foundations, not meaningful innovations solving real problems. Examples include Coinbase, OpenSea, etc. The bottom line is, distribution trumps innovation. Not that I see myself working in the web3 space, but this stint feels like a decent opportunity to network and explore more.

The semester is over. I feel I am done with building projects now. They still excite me, but the monetary aspect of it is more appealing now. I’d like to focus on building and solving more business-oriented problems. The Summer internship starts in a few days. At 24 °C, New York feels warmer now. People are out and about, and the city is alive. I’d like to save up for a few trips this summer, mostly exploring places around the Bay Area.

Orion is going well. The device is currently capable of recording various muscle signals based on activity, and the data shows distinguishable patterns between relaxed, fist, index, and index-middle finger positions. It conditions signals using moving average filtering, rectification and envelope signals with additional raw signals for improved accuracy. The challenge here is improving the deep learning model that has a terrible accuracy of around 60-70% for the current dataset. The annoying part about this is that the data is terrible. Primarily, because the jumper wires kept falling off, and the electrodes were not placed properly. Also, the muscles get fatigued after a while.

Recording muscle data fluctuations which will be later used for analysis and model training.

Left, Mid: Arm with electrodes and sensors, Right: MCU with electrodes and sensors live

Further, in the next semester, I am planning to integrate a language recognition model that will be used to convert the signals into text. This has a lot of potential applications, including controlling devices, typing (air keyboard), and even hand-gesture-to-speech conversion.

New York in spring is as beautiful as ever. The highs are around 20-24, and the lows are around 12-14, the sweet spot. The cherry blossoms are in full bloom, and the city feels lively. Charting out a few short trip plans for the summer. The East Coast isn’t as scenic as the West Coast, but let’s see how it goes.

Currently watching When Life Gives You Tangerines, a Korean series that beautifully explores themes of love, loss, and self-discovery. The story follows a young woman as she navigates the complexities of relationships and personal growth. Stunning cinematography and heartfelt narrative. Also, You, a psychological thriller series that follows Joe Goldberg, a charming yet dangerous psychopath who becomes obsessed with the people he loves.

The last ten-odd days were disturbing and I was glued to the news. The situation back home is heartbreaking. What is more annoying is that all of the news channels are too polarised; thus, instead of providing information, they spend more time on sensationalism. I have faith that India will have a response ready. Vengeance is coming. Jai Hind.

April

Too many projects and short stints; dropping all projects for now. Planning to slow down a bit and try to focus on one clear domain to build something tangible. Let’s see how this turns out. I’d still have to finish Orion, for it is part of my academics. New York life is beautiful. Spring is starting, and the city looks lovely! Also got a new gig that I am pretty excited about. I got a Tech Product Engineering internship for this summer at YourMove.ai, an AI-based product that helps you in your dating life.

College life is slow but more meaningful. Formal education and I seem to be done with each other. Thus, this semester, almost half of my credits are just projects. Ferry is almost done, and I am focused on wrapping up Orion. (More details here). Will try to keep up the pace next semester as well and graduate early. Spending most of my time on product strategies, design, architecture and case studies: product market fits.

Helped out a friend this weekend build an AI-accelerated hardware simulator in ‘C’ and Verilog to demonstrate vector multiplications and speedup in hardware. The benchmarks show massive speedup in TPUs and NPUs: O(1) vs O(n) in CPUs by running the multiplication in parallel.

This weekend was productive. Decided to revisit an old decentralised, encrypted chat app I built three years ago, and here is the v2: https://anubhavp.dev/fireside/. Also, implemented a global search feature in this blog. Search for any content in the blog on any page, using the search icon, or ctrl/ cmd + k or /. The search is implemented using a custom prefix-matching plus a fuzzy search engine that uses the BM25 ranking algorithm. At times, there are these one or two out of a thousand scenarios where I sometimes contemplate that maybe Leetcode has had some value in my software engineering journey.

F-ed up my PC for a day. Ferry is not programmed to handle malformed code, and the IR-assembly code generation missed adding epilogue to this one for-loop in a test.c file. Ferry uses spike to emulate the RISC-V assembly code, and it started an infinite loop with seg faults and stack overflows. I quit the emulator (ctrl + c) and was on my way, but spike was silently running in the background. A day later, my CPU Fan started roaring, and the laptop was heating up. Initially, I ignored it, but later, upon inspection, it was clear today why tests are important in your code. Spike was hogging 99.5% CPU usage.

Gemini-2.5-pro is the new hot thing in the AI space. Reddit users are reportedly reporting massive performance differences from Claude 3.7-sonnet. On the contrary, my experience has not been quite the same. When I asked it to analyse Ferry, my C compiler project, it did successfully analyse it in one shot, identify bugs and suggest improvements. But the code generated by Gemini 2.5-pro was buggy, with unreadable characters (this one time it generated a weird character which I hadn’t seen in ASCII before xD), and a lot of unused variables, amongst others. The code also didn’t solve the problem.

Currently, Ferry is riddled with bugs, primarily in the IR to Assembly space, mainly because I mostly wrote all the template code myself and asked Claude to fill in the rest.

March

Claude finally has a web search feature; I can finally let my ChatGPT+ rest in peace now. Well done, soldier. You did well. (Immediately regrets after looking at the Ghibli art images everyone is generating) :(

Happy Holi, folks! I had a lovely Holi celebration here this weekend. Currently wrapping up Ferry, a C compiler in Rust. The compiler is currently capable of parsing, tokenising, generating an AST and an optimised intermediate representation of the code for a subset of the C language. The following steps would be to compile IR to RISC-V assembly.

Compiled languages are always faster than interpreted languages, which is why Microsoft has also announced a native port of the TypeScript compiler to Go, which was earlier written in TypeScript.

I am also contributing to a process isolation sandbox project, LIND, at the Secure Systems Lab at NYU and in some research about Meta’s Orion Glasses, particularly focusing on hand-gestured controllers.

The internet is going crazy since the launch of Claude 3.7 sonnet and for the right reasons. Claude 3.7 destroyed benchmarks, which is a significant improvement over other models. I tried out Claude, and it’s just insane. For instance, I asked it to review an article I wrote earlier with the default prompt provided by Anthropic (look for the polish your prose suggestion in Claude), and it just nailed it.

Now the question is, do I replace my ChatGPT+ subscription with Claude? Claude doesn’t have a web-search feature, yet. But I switched, crossed the line, and made the jump to the dark side. I wish it had a web search feature. It could be a separate entity, like a separate web scraper model, or maybe a separate tab in the app, or something. This would solve all my problems and would be a game-changer. I used ChatGPT for every single thing, from research and coding to analysing the nutritional values of food. For example, every day, I ask ChatGPT to find the nutritional values of a food item, like say a particular branded milk/ oat milk or a coffee from Starbucks, and it still does a great job at it. To maintain a log, I ask it to save all the results in a markdown file and return.

The other solution now is using Google as usual (Google does a better job than the likes of Perplexity at finding relevant sources, BUT, for summarising, paraphrasing & “how to” queries, an LLM-based search engine is better. Refer to this article), and then copy-paste the results to Claude.

Is it March yet? I remember going back home, to India, for a break, like it was yesterday and now two months are already over? Strange. On this side of the world, I am currently building a compiler for a subset of the C language to RISC-V assembly language. It’s a fun project that helps me understand how compilers work. I also joined the SSL (Secure Systems Lab) at NYU, and am involved in a project aimed at building a secure system that aims to isolate processes in a single process sandbox. This helps limit the damage caused by bugs or security flaws in the application. Also, involved in some research about Meta’s Orion Glasses because I found the hand-gestured controllers fascinating. I am planning to work this semester on a controller as such. Excited to see how all these unfold in the coming months.

February

The highlight has to be HackNYU, a 48-hour hackathon that I participated in last weekend. We built Neighbourly, a hyperlocal community inventory management app for you to donate, borrow, or exchange food and essentials with those in need. We didn’t win, but I am proud of what we accomplished in the given timeframe. Here’s the gist of the project on Devpost. We built the skeleton in a few minutes using tools like v0.dev, blot.new, rollout.site, and presentations.ai. It’s crazy how AI has changed the landscape of today’s development.

Tech is a commodity now; anyone with a slight sense of what they are doing can build something. I don’t see the point in hiring a lot of developers to build something that can be done by a few now. I get what FAANG companies mean when they lay off a lot of devs. Not that I support that, but it just makes more fiscal sense. The real challenge is to build something that people want.

January

Back in action: January was like an amazing, much-needed, magical vacation back home, and now I am back, and it feels good. I met my cousins, family and relatives, ate a bunch of good Indian food, and spent a lot of time with my friends, still unsure how a month went by and if I was ready to get back to work. My sister got married, and I still can’t digest this. She is just six months older than I, and we grew up together, inseparable. I am happy for her, but it feels like a part of me is missing. I can’t wait to finish things here and rush back home.

Currently reading The Short Case for Nvidia Stock by Jeffrey Emanuel, which explains how Deepseek, an open-source LLM, just killed it in the LLM space. The training of DeepSeek-V3 required less than $6 million worth of computing power with Nvidia H800 chips, which is 20 to 50 times cheaper than the cost of training similar models by OpenAI and Anthropic. On Monday, January 27, 2025, the stock closed at $118.42, marking a 17% drop from the previous close. This decline erased nearly $600 billion from NVIDIA’s market capitalisation, setting a record for the largest single-day loss in U.S. history. The stock’s decline was attributed to a combination of factors, including a broader market sell-off, concerns about the company’s growth prospects, and a downgrade from analysts at Morgan Stanley.

Taking a break:

I am going back home this month. If you’re curious, I will be spending more time on my books, PS5, and Netflix in the next few weeks. Red Dead Redemption, Spiderman 2, Pulp Fiction, The Godfather, and a long list await this new year. Hoping to gobble up good food for the rest of the year in this one-month break.

Here’s to new beginnings and new adventures! 🥂 I hope you have a great year ahead. Merry Christmas, and a happy New Year, everyone! Promise to be back soon. Keep checking :)

2024
2023

Dough - A Rich Presentation Tool

Anubhab Patnaik — Wed, 31 Jan 2024 00:00:00 GMT

Imagine a presentation tool that seamlessly blends simplicity with power. Welcome to Dough – your new favorite presentation companion. Say goodbye to clunky interfaces and hello to a tool that’s as intuitive as it is efficient.

Why Dough?

(Why, though? - Get it? xD)

At StackIt, the team gathers every Saturday for their weekly showcase. Each member presents their progress, showcasing the fruits of their week-long hike. Inspired by this collaborative spirit, I came to the idea of Dough - a presentation generator tool like no other. Built in Rust, Dough is a rich, modular, command-line tool to generate presentations. I found similar tools like slidev by antfu and presenterm that inspired me to create Dough.

Features

Dough’s modular design allows for seamless customization. You can customize the color scheme, the alignment, and the syntax highlighting of the code blocks, and even the runtime of the code blocks.
Align content both horizontally and vertically and also specify the alignment of individual text segments. You can decide between having a margined presentation or one without margin anywhere, in the bottom, left, or centre, of the screen.
Code blocks have syntax highlighting, and also support code execution. You can run your code and the output will be displayed in the presentation. The code blocks run in a separate thread and the main thread displays the output in the terminal. The code blocks are internally ordered in the order they appear in the markdown file.
Dough will also be supporting images in the terminal for the ones that have a GPU-enabled terminal like Kitty or iTerm2.
You can choose to use templates. The optional --template flag is used to specify the template. The default template is used if not specified. If not, simply spawn a new folder and a markdown file, and you’re good to go. Dough’s intuitive navigation system lets you scroll through slides with ease. You can choose between scrolling top-down or bottom-up. Presentations start from 1 to the last slide. Dough supports arrow keys and VIM keybindings to navigate through slides. There are two modes of navigation:

Highlight a line as you scroll through the slides.
Scroll through the content of the slide.

Dough supports hot reloading. You can edit your markdown file and do a ctrl+r to reflect in the presentation instantly. The auto hot reload is still in the works.

The default style settings are stored in a style.yaml file which looks like this: style.yaml

Unveiling the Core

Dough thrives on markdown, transforming simple text files into captivating slides. Leveraging the syntax of pulldown-cmark, it effortlessly transforms your ideas into visual stories.

Projects are created by simply writing a markdown file inside a folder. The folder name is the name of the project. Just mkdir my_folder and touch my_folder/1.md and you’re good to go. You can also use templates using the new command. The slides are presented using the present command. The optional --template flag is used to specify the template. The default template is used if not specified.

At the heart of dough lie two pivotal components:

Renderer: This component takes charge of the visual rendering of slides.
Parser: Responsible for dissecting markdown files and converting them into a structured format.

The parser parses the markdown file, prettifies it, and then passes it to the renderer to render it. The renderer then renders the slide in the terminal to display it.

The parser takes in the markdown text and converts it into Nodes of mdast(markdown abstract syntax tree). The tree is reccursively traversed and each node is then styled according to the Node ( Markdown Element ) type. After combining all the nodes, a prettified version of the text is returned. It then modifies the prettified content, applies custom alignment, styles, and spacing, and adds a margin to the content to fit the terminal.

There are two stages of rendering:

The renderer takes in the prettified content and renders it in the terminal.
The renderer then handles the navigation actions, the scrolling mechanism and the keybindings. It controls the flow of the presentation and is responsible for rendering the slides in the terminal. It switches between presentation and highlighting mode and also handles the code execution.

Here is the source code of dough - Dough

Contributing

If you’re eager to dive into the world of Rust and looking for a project to contribute to, Dough presents an exciting opportunity. Here’s a breakdown of what’s currently working and what areas could benefit from your expertise:

What’s working and what’s not?

Fix scrolling issue in highlight mode:
- bug Over Scroll in infinite scrolling
- feat Skip empty lines in highlight mode
bug custom aligner adds empty lines after text-block alignment
feat. Hot Module Reload
feat. Add support for the maximum width and height of the presentation. Write a word wrapper.
feat. Add comprehensive support for common Markdown elements.
feat. Enhance rendering for complex markdown elements like links within headings or lists.
- lists.
- blockquotes.
- tables.

Feel free to explore these areas, open new issues, or submit pull requests to contribute to Dough’s evolution. Your insights and contributions are highly valued as we strive to make Dough the go-to presentation tool for Rust enthusiasts everywhere.

Let your presentations shine like never before :)

Your browser does not support the video tag.

Fall, 2023 - Kedarnath & Dubai

Anubhab Patnaik — Mon, 23 Oct 2023 00:00:00 GMT

This fall, I spent two of the most glorious weeks of my life, one in the mountains, chasing the clouds, and the other in the desert, tanning under the sun. The journey was filled with love, nostalgia, and a sense of freedom as I explored a part of adulthood.

A trek to Kedarnath

The journey started from Bangalore. Mukul and I live in Bangalore, and we left for Delhi on the 7th of October. We boarded the train and had a great time. We got ourselves an AC coach and settled in. The journey begins!

Upon reaching Delhi, we stayed with Mukul’s sister for a day. We met the rest of the gang, Hritik and Hemant, who had come from Jamshedpur. We had an evening to kill and thus decided to explore the old city, rich with history and culture. We roamed around the streets of Chandni Chowk and Chawri Bazar, looked for flea markets, and ate a ton of fast food which you might guess- I would have regretted later. These places had been bookmarked by me for a long time now, and I finally got to visit them. Our day was filled with visits to iconic landmarks, including the magnificent Jama Masjid and the Red Fort.

Purani Dilli

We left for Haridwar at midnight and reached there at the break of dawn, around 4 in the morning. We scoured for cabs and found a cheap one right in front of the railway station, and went straight to Sonprayag. En route, we explored numerous river confluences, each referred to as a “Prayag.”

The literal meaning of Prayag is “confluence,” and it signifies the meeting point of two or more rivers. The most famous Prayag is Triveni Sangam, where the Ganga, Yamuna, and Saraswati rivers converge. The Ganga is considered the most sacred river in Hinduism, while the Yamuna is associated with Lord Krishna, and the Saraswati is believed to be a mythical river that no longer exists. There are five major confluences in the region, each with its significance, in Uttarakhand. The Ganga is formed at a place called Devprayag.

From Sonprayag, we left for Gaurikund, the starting point of the trek to Kedarnath. During the journey, we spoke about our lives and how life had changed over the years. The 2013-14 teenage years were filled with fun and excitement. We spoke about those kids in those days in Jamshedpur, unbothered and oblivious to the world around them, and now how after 10 years, having grown up, we were all set to explore the world. We talked about what each of us plans to do in the future, and how our lives had changed since we had graduated from high school. It took us 12 odd hours to reach Gaurikund and we were exhausted. Sensibly, we decided to rest and begin the trek the next day.

Woke up early the next day, freshened up, and prepared for the trek. Hemant and Mukul, exuding fumes of enthusiasm, and energy radiating, looking all tough, shouldered their backpacks and set out for the trek’s starting point. I was a bit sceptical of my skill. I pretty much knew I wouldn’t be able to complete the entire trek on foot. The 22-kilometer, steep journey seemed daunting. Hritik freshened up as well, and we all went ahead to start the trek. Mukul and Hemant were ahead of us. They didn’t wait for me as I was slowing down everyone. Hritik walked with me and tried to push me to cover as much as I could and advised me not to take frequent breaks. Carrying a few extra kilos, I found it extremely cumbersome to trek. I had to pause every 100-200 meters, mustering every ounce of courage and strength to continue. I was not accustomed to such strenuous physical activity, and the steep ascent was taking a toll on me. Plus, I was not in the best shape and was not physically prepared for the trek.

Somehow, I managed to trek for six and a half km. Hritik, Mukul and Hemant urged me to trek on a mule. The route offered mule transportation for those who found it challenging to ascend on foot. Initially, I was equally excited as the rest and didn’t want to succumb and get on a mule. However, after enduring the gruelling climb of the first 6 kilometres, and considering the unanimous request, I realized that it would be unfair of me to hold back the group.

With Hritik by my side, we decided to mount mules and proceed with the journey. Upon reaching, we paid an incredibly high price for a plate of Maggie and halted. The Maggie plate and the view were worth it. Mukul and Hemant reached after an hour, tired and looking like their souls were almost ready to succumb to fatigue. Hritik, Mukul, and Hemant set off in search of the campsite to rest and recuperate. Mukul looked as if he was on the brink of exhaustion and was borderline dead. I decided to hang back, explore the hills, and click photos.

Maggie and the view

I came to the tent after having witnessed the magnificent sunset that I saw up on the hill. All of us were exhausted, and we went to sleep quickly and just woke up for dinner. During the night, the temperatures plummeted to -3 degrees Celsius.

Gangotri Range

The following morning, we awoke from our snug sleeping bags and prepared to visit the temple, our spirits high. We went near the temple, and the view was breathtaking. The temple was surrounded by snow-capped mountains, and the sun was shining brightly. We were all in awe of the beauty of the place. Hritik decided to buy gifts for his family and friends. We went ahead and bought some stuff for our families as well. After the shopping, we went ahead and stood in the queue for the temple. The queue was long, and it took us 3 hours to reach the temple. We heard that someone from the Ambanis had come to visit the place and the temple was closed for 3 tedious hours.

Standing there, I eavesdropped on the conversations of the people around me. My mind got busy wandering, travelling to various places in various stories, exploring multiple character arcs and their views of rights and wrongs. I was engrossed in my own thoughts, contemplating morality through the lens of these characters. I was lost in the stories of the people around me, their lives, their struggles, and their aspirations. Until I heard the temple bells ringing.

The Gang and the temple

We went inside the temple, and the atmosphere was serene. After returning to the campsite in Kedarnath, we collected our belongings and I found out that my power bank had been stolen. With a heavy heart, we started our descent. We reached the campsite, and we were all tired. We had our dinner and slept.

Journey back

The following day, we embarked on our journey to Haridwar. The return journey was beautiful. We were tired, having successfully completed the trip and were all in high spirits. We reminisced about our childhood days and the memories we had made. We were all happy and content. Hritik told us how hard his breakup was on him, while me and Mukul made fun of him. Hemant told us that he got a quarter where he later found out that someone had died and decided to switch places. Now, he had to live with his brother while he awaited a new quarter. Somehow six hours passed, and we reached Haridwar.

After reaching Haridwar, we stowed our belongings in a room booked by Hemant. That evening, we roamed the enchanting streets, particularly around the ghats. It was a magical experience. As we explored the bustling markets of Haridwar, we indulged in a variety of food, finally catering to our appetites after being starved for 3 days. Hritik decided to bathe in the Holy Ganga and I joined him and dipped my feet in the sacred water. We also visited several temples, walking down memory lane. We explored old paintings on the walls, discussing mythology and the stories behind them.

We had a train to catch at 11:45 p.m., and at 12, we left for Delhi.

At that point, my journey took a different direction. While the rest of my friends remained in Delhi, I boarded a flight headed for Bhubaneswar, concluding this unforgettable adventure with memories that would last a lifetime.

Coming back home is always great. Khusi had flown in from Dubai for her fall break, and we had decided to go visit Dubai the next week, together. The day after that, both Khusi and I embarked on our journey to Dubai, ready for the adventures and experiences that awaited us in this vibrant city.

Marhaba, Dubai

Dubai proved to be a surreal experience, marking my first international trip outside of India. As I boarded the flight, the first thing that caught my attention was the extended flight time. Our journey spanned 4 hours and 15 minutes from Bhubaneswar to Dubai International Airport.

Initially, I grappled with homesickness and longed to go back to Bangalore. I was away for more than a week and this feeling was making me uncomfortable. Most of my tension was due to my work. A lot of things were pending, and Stackit has just launched. Being the only senior engineer, I had to make sure everything was in place. Dubai was a new place, and I was apprehensive about how I would adapt. I didn’t know anyone here and felt left out. Dubai was turning out to be a bum. I stayed indoors, did not interact with anyone, and was homesick and worried about going back.

However, after a few days, I gradually acclimated to the city, and my initial reservations gave way to enjoyment. I was amazed by the cleanliness of the city. The roads were clean, and the people were disciplined. The architecture was magnificent. Dubai is a giant city inside a desert. The city is filled with skyscrapers, and the roads are wide. Moreover, the diversity of its population was striking, with people hailing from all corners of the globe, making Dubai a truly global metropolis.

During our stay in Dubai, we rented out an apartment near where Khusi lives, for our accommodation. Each morning, as Khusi headed to her office, I would set up my daily standup calls and tackle the day’s tasks and responsibilities. We both would try to finish off our work by pre-evening and would hop on the bus and travel towards the metro to explore the city.

Room -1

Apartment

Khusi and I visited the Mall of Emirates. We roamed around the place, realizing that we were too poor to be looking at any of the retail outlets. We explored various shops, eateries and fancy dessert shops. I bought her a cap and a pillow. We got groceries for the week.

She also introduced me to the places nearby. I decided to get a haircut done and made friends with the barber who belonged from Kerala. He told me about his life in Dubai and how he was planning to go back to Kerala. I told him about my life in Bangalore. We chatted about regional languages. He was a movie buff and asked if I had watched Leo yet. Leo stars Vijay, his favourite actor, after which I promised I would watch it. I haven’t watched it yet.

The following day, our adventure led us to the Dubai Mall, along with a visit to the Burj Khalifa. I was asked to get an Apple watch by a junior colleague. I visited the Apple Store and urged Khusi to get me something but she refused. After a ton of shopping, we left and roamed around in the streets, exploring Dubai until late at night. I realized that Dubai is a city that never sleeps, and somehow most of the cab drivers here are either from India or Pakistan. The streets were bustling with people, and the city was alive with activity. We had dinner at a restaurant and then went back to our apartment.

Burj Khalifa

Over the next few days, we explored Bur Dubai with our friends, often also known as the “Little India” in Dubai, known for its extensive collection of electronic shops. We also visited a gold market, because gold is cheaper in Dubai than in India. We immediately brought out our inner Indian, put on a bright face, and prepared to bargain the hell out for the things that we wished to buy to death. I got Marshall Kilburn II: an amazing speaker. The five of us went ahead and had dinner beside a lake, where we spoke about our college days and then explored a chocolate shop to get souvenirs for our friends in India.

After six days of extensive exploration, we decided to have a breather on a Saturday morning and went swimming in the apartment’s swimming pool with our friends. That evening, we set out to visit the Palm Jumeirah, an opulent and magnificent hotel in Dubai known for its attractive theme parks and immersive experiences. We had dinner there and witnessed a live band perform. We then went ahead to explore an Indian Pub, Havelli. It was loud and typical. Havelli reminded me of home, where we had our dinner. Khusi danced and made friends with strangers. Our card bills soared high, and we decided to head back to our apartment.

My scheduled departure back to India was set for Sunday, the 22nd. On that morning, we made our way to Kite Beach. I was in awe at how clean the beaches were. Having lived my life in Bhubaneswar, close to Puri, an iconic beach in India, I couldn’t believe how amazing this place was as compared to Puri, where tourists have made it a trash can of all sorts. We had breakfast at a cafe and then went ahead and explored the beach. The beach was filled with people from all over the world.

Kite Beach

Before bidding adieu to this captivating city, we indulged in ice cream and mocktails and chatted a lot about how things were going on in our lives. We roamed on the beach, scouting for hats and sunglasses and bought Oud perfumes. While our feet sank into the soft sand, we delved into discussions about life in different countries and argued about which was better. We knew in our hearts that all we wanted was to reside in the same place. With fond memories in our hearts, perhaps some flaky promises and a heavy heart, we made our way to the airport embarking on my return journey to India.

Ferry - A C compiler for RISC-V

Anubhab Patnaik — Tue, 25 Mar 2025 00:00:00 GMT

The ferryman is a figure in various mythologies responsible for carrying souls across the river that divides the world of the living from the world of the dead.

JK. This post is the second in a series of posts that explore the world of compilers, interpreters, CPUs and low-level systems. The previous post describes how the CPU works; and how CPUs process and execute instructions. This post explains how the code you write in a high-level language is transformed into machine code that the CPU can understand and execute.

Recap: A brief overview of how high-level languages are compiled into machine code.
- Machine Code: Compiled code that the CPU can execute.
Computer Architecture: Understanding the components of a computer system. Why are compilers CPU-specific, while interpreters are not?
Ferry: A simple C compiler that compiles to RISC-V assembly.
- Walkthrough: Compiling Ferry
  - The Subset of C supported: The features of C that Ferry supports.
- Core: Compiling a simple C program.
- Lexical Analysis: Converting the input code into tokens.
- Syntax Analysis: Checking the syntax of the input code.
  - AST: The abstract syntax tree representation of the input code.
  - Semantic Analysis: Checking the semantic correctness of the input code.
- Intermediate Code Generation: Generating an intermediate representation of the input code.
  - Optimization: Optimizing the intermediate code for performance.
- Code Generation: Intermediate code to assembly code.
- Assembly and Linking: Using an external assembler to convert assembly code into machine code.
  - Instruction decoder: A tool to decode RISC-V instructions and convert them to assembly code.
Yatch: A simple machine code interpreter for RISC-V.
Future Work: Next?

This next section is a quick recap taken from the previous post-Docking Compilers. If you are already familiar with how the CPU works, feel free to skip here.

Compiling High-Level Languages

Compilers and interpreters are tools that convert high-level programming languages into machine code instructions that the CPU can execute. Compilers translate the entire program into machine code before execution, while interpreters translate and execute the program line by line.

For ex.

x = 5;

Can be compiled into assembly code like this:

li x1, 5 // load immediate 5 into register x1
sw x1, 0(x0) // store word 0 at address x0

This assembly code is then translated into machine code, which is a binary representation of the instructions that the CPU can execute. The CPU executes these instructions in a sequence, and the program runs.

While interpreters translate and execute the program line by line. The interpreter:

reads the source code line by line,
translates it into machine code (or bytecode in HLLs),
translates bytecode into machine code and runs it in a virtual machine.

This allows dynamic typing, interactive debugging, and easier integration with other languages. However, interpreters are generally slower than compilers because they don’t optimize the entire program before execution.

Machine Code

Binary code is run as instructions on the CPU. The CPU executes these instructions in a sequence, and the program runs. Each CPU has its own set of instructions it can execute, known as the instruction set architecture (ISA). The ISA defines the instructions the CPU can execute, the registers it uses, and the memory model it follows. For example, an instruction might look like 00000000000000000000000010000011, which translates to lb x1, 0(x0) in RISC-V assembly. This instruction, specific to the RISC-V ISA, loads a byte from memory into register x1.

Computer Architecture

Computer architecture is the design of computer systems, including the CPU, memory, and I/O devices. The CPU executes machine code instructions, which are specific to the CPU architecture. CPU architectures like x86, ARM, and RISC-V have different instruction sets and memory models. Each instruction set has its own assembly language and machine code format.

Here’s why it is important to understand computer architecture: Compilers generate machine code specific to the target CPU architecture. The machine code for x86 is different from ARM or RISC-V. Interpreters, on the other hand, are CPU-independent. They translate high-level code into bytecode or an intermediate representation that can be executed on any platform.

Ferry

Ferry is a simple C compiler written in Rust that compiles to RISC-V assembly. It is not a complete implementation of the C language, but a good starting point for understanding how compilers work.

I would suggest getting a basic understanding of how Rust works, and how to set up a Rust project before diving further. Just the basics. Find the Rust Book here.

Walkthrough

Compiling Ferry is a pretty straightforward:

cargo build --release

and use

./target/release/ferry <input_file.c>

to run the compiler.

An assembly file with '<input_file>.s will be generated in the same directory as the input file.

The assembly code can be assembled into machine code using an external assembler like riscv64-unknown-elf-gcc. Or, feel free to use an online assembler like RISC-V Online Assembler.

cargo run --release --bin runner -- <input_file.s>

to run the code in Mac OS (Apple Silicon - arm64). This will assemble the code and run it using qemu-riscv64.

The Subset of C supported

Before moving forward, Ferry only supports a subset of C. The following features are supported:

Basic arithmetic operations (+, -, *, /, %)
Variable declarations and assignment
Basic types (int, char, float, double)
Control flow statements (if/else, while loops)
Function declarations and calls
Arrays (fixed-size only initially)
Basic I/O functions (simplified printf-like functionality)
Comments (just for readability, your tokenizer already handles this)
Pointers (basic pointer operations)
Typecasting (implicit and explicit)
Structs (without unions initially)
String manipulation (basic operations)
Basic preprocessor (#include for essential libraries)
For loops

Core

Building a compiler is a complicated task. Ferry takes in a program written in C and generates assembly code for the RISC-V using the following steps:

Source Code --> Parser --> AST --> IR Generator --> IR Optimizer --> Assembly Generator (.s) --> Assembler (.o) --> Linker (executable)

Lexical Analysis: The first step in the compilation process is to break the source code into tokens. This is done using a lexer, which reads the source code and generates a stream of tokens. Each token represents a meaningful unit of the source code, such as a keyword, identifier, or operator.
Syntax Analysis: The second step is to parse the tokens generated by the lexer and build an abstract syntax tree (AST). The AST is a tree representation of the source code, where each node represents a construct in the source code, such as a variable declaration or function call.
Semantic Analysis: The third step is to check the AST for semantic correctness. This includes checking for type errors, variable declarations, and function calls. The semantic analyzer verifies that the types of variables and expressions are correct and that functions are called with the correct number and types of arguments.
Intermediate Code Generation: The fourth step is to generate intermediate code from the AST. The intermediate code is a low-level representation of the source code that is easier to optimize and translate into machine code. The intermediate code is usually platform-independent, meaning it can be executed on different architectures.
Code Generation: The final step is to generate machine code from the intermediate code. The machine code is a binary representation of the instructions that the CPU can execute. The code generator translates the intermediate code into machine code specific to the target architecture.

Assume we have a simple C program:

#include <stdio.h>

int main() {
  printf("Hello, World!\n");
  return 0;
}

The following code is the exact implementation of the compiler with abstracted implementations of the steps.

fn compile(file: String) -> Result<bool, String> {
 // Parse the source code
    let mut ast = parse_source(&file)?; // Parse the source code into an AST
 // Perform semantic analysis
    ast = semantic::analyze_semantics(ast)?; // Perform semantic analysis on the AST
 // Generate code from the AST
    ir::generate_ir(&ast)?;
 // Assembly generation
    let assembly = codegen::generate_assembly(&ir)?;
    Ok(true) // Return true to indicate successful compilation
}

The assembly code is platform-dependent, meaning that the same high-level code can be compiled into different assembly codes for different architectures. The assembly code is then assembled into machine code, which is specific to the target CPU architecture. Jump to the Assembly and Linking section to see how the assembly code can be converted into machine code using an external assembler.

Lexical Analysis

The compiler reads the source code and breaks it down into tokens. Tokens are the smallest units of meaning in the code, such as keywords, identifiers, literals, and operators.

pub fn parse_source(source: &str) -> Result<(), String> {
    let tokens = tokenize(source)?;
    let mut _ast = build_ast(&tokens)?;
    Ok(())
}

For our example, the tokens generated from the source code would look like this:

Token Stream:
PreprocessorDirective("#include <stdio.h>") --> header file  
Type(Int) --> type of variable  
Identifier("main") --> function name  
LeftParen --> opening parenthesis  
RightParen --> closing parenthesis  
LeftBrace --> opening brace  
Identifier("printf") --> function name  
LeftParen --> opening parenthesis  
String("Hello, World!\n") --> string literal  
RightParen --> closing parenthesis  
Semicolon --> semicolon  
Keyword(Return) --> return statement  
Number(0.0) --> return value  
Semicolon --> semicolon  
RightBrace --> closing brace  
EOF --> end of file

Syntax Analysis

After tokenization, where the source code is broken into tokens, the syntax analyzer (parser) processes these tokens according to the language grammar rules. As it recognizes valid syntactic structures, it constructs the AST. The AST is the output or result of the syntax analysis process.

Each time the parser recognizes a valid language construct (like an expression, statement, or declaration), it creates the corresponding AST nodes.

The parser uses a recursive descent parsing approach, where each function corresponds to a grammar rule. For example, the parse_expression function handles expressions, while the parse_statement function handles statements. The root level function, parse_program, is responsible for parsing the entire program, which then calls the other parsing functions as needed.

The parse_program function might look like this:

match &self.peek().token_type { // Check the type of the next token
  TokenType::Type(_) => { // If it's a type, parse a declaration
    let declaration = self.parse_declaration()?;
    program.add_child(declaration); // Add the declaration to the program
 } 
  TokenType::PreprocessorDirective(_) => { // Else if it's a preprocessor directive, parse it
    let directive = self.parse_preprocessor()?;
    program.add_child(directive); // And the directive to the program
 }
  _ => {
    return Err(format!("Expected declaration, found {:?}.", // Error if neither
    self.peek().token_type));
 }
}

The declaration_parser function would then handle the parsing of variable declarations, function declarations, and other constructs. It would create the appropriate AST nodes for each construct and add them to the program node.

AST

The Abstract Syntax Tree (AST) is a tree representation of the source code. Each node in the tree represents a construct in the source code, such as a variable declaration, function call, or control flow statement. The AST is used to represent the structure of the program and is an intermediate representation that can be further processed by the compiler.

A node in the AST might look like this:

pub struct ASTNode {
    pub node_type: ASTNodeType,
    pub children: Vec<ASTNode>,
    pub value: Option<String>,
}

The parser generates the AST by creating nodes for each construct in the source code. For example, a function call might be represented as a node with the type FunctionCall, and its children would be the arguments passed to the function and the function name.

In our example, the AST for the entire program would look something like this:

AST Structure:
└── Root --> root node
├── PreprocessorDirective: Some("#include <stdio.h>") --> header file
└── FunctionDeclaration: Some("main") --> main function declaration
    ├── Type: Some("Int") --> type of function
    └── BlockStatement: None --> block of code starts
        ├── ExpressionStatement: None --> this node doesn't carry any specific value itself - it's just a container that holds the expression
        │   └── CallExpression: Some("printf") --> function call (from stdio.h)
        │       ├── Variable: Some("printf")  --> function name. During the semantic analysis phase after parsing, the compiler would verify that this identifier actually refers to a callable function.
        │       └── Literal: Some("\"Hello, World!\n\"") --> string literal
        └── ReturnStatement: None --> return statement for the function
            └── Literal: Some("0") --> return value

Semantic Analysis

The semantic analyzer checks the AST for semantic correctness. It verifies that the types of variables and expressions are correct, that functions are called with the correct number and types of arguments, and that variables are declared before they are used. The semantic analyzer also performs type checking and resolves any ambiguities in the code.

It checks for preprocessor directives, variable declarations, function declarations, and function calls, and removes any unnecessary nodes from the AST like the #include directives.

For example, assuming there is a #include<matlab.h> directive in the code, and the code looks like this:

#include <matlab.h>
int main() {
 Matrix m = createMatrix(3, 3); // Function declared in matlab.h
    return 0;
}

The semantic analyzer would check that the createMatrix function is declared in the matlab.h header file and that it is called with the correct number of arguments. It would also check that the Matrix type is defined in the header file and that it is used correctly.

After preprocessing, it might look like:

typedef struct {...} Matrix;
Matrix createMatrix(int rows, int cols);
// ...many more declarations...
int main() {
 Matrix m = createMatrix(3, 3);
    return 0;
}

The linker would then resolve the references to the createMatrix function and the Matrix type, ensuring that they are defined in the correct header file.

In our original example, the semantic analyzer would check that the printf function is declared in the stdio.h header file and that it is called with the correct number of arguments. If any semantic errors are found, the compiler reports them to the user.

In the printf("Hello, World!\n") statement, the semantic analyzer checks that the printf function is called with a string argument. If the argument is not a string, it raises an error.

Two specific functions handle this case:

pub fn check_types(node: &ASTNode, symbol_table: &SymbolTable) -> Result<Type, String> {
  ...
  if value.starts_with('"') {
    Ok(Type::Pointer(Box::new(Type::Char))) // String literal
 } else if value == "true" || value == "false" {
    Ok(Type::Bool)
 } else {
    ...
 }
  ...
}

and

pub fn check_types(node: &ASTNode, symbol_table: &SymbolTable) -> Result<Type, String> {
  ...
  match (target_type, value_type) {
 // Basic types
 (Type::Int, Type::Int) => true,
 (Type::Float, Type::Int) => true, // Implicit conversion
    ...
 // Pointers
        
 // For box types, recursively check if the inner types are compatible
 (Type::Pointer(target_inner), Type::Pointer(value_inner)) => {
      is_type_compatible(target_inner, value_inner)
 }

 // Functions are compatible if their return types and parameter lists match
    if !is_type_compatible(target_return, value_return) {
      return false;
 }
 }
}

This step raises compile-time errors if the AST is not semantically correct.

Intermediate Code Generation

The intermediate code generator converts the AST into an intermediate representation (IR). The IR is a low-level, usually platform-independent representation of the code that is easier to optimize and translate into machine code.

AST represents the syntactic structure of the code (closely mirrors source code) while IR represents the semantic operations (closer to what the machine will do). IR is specifically designed for optimizations that are difficult at the AST level. Common optimizations like constant folding, dead code elimination, and loop transformations work better on IR.

IR representations are usually standardized and can be used across different compilers. LLVM IR is a widely used intermediate representation that is used by the LLVM compiler infrastructure. It is a low-level, typed assembly-like language that is designed to be easy to optimize and generate machine code from. It is often represented as a three-address code, where each instruction has at most three operands. An LLVM IR representation of the code might look like this:

@.str = private unnamed_addr constant [14 x i8] c"Hello, World!\00", align 1
define i32 @main() {
entry:
 %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i32 0, i32 0))
 ret i32 0
}

Compilers typically use multiple IR forms during compilation:

High-level IR: A Tree representation of the source code, easier to analyze and optimize.
Low-level IR/ Linear/Three-address code IR: Each instruction typically has one destination and up to two source operands. Closer to assembly language

Ferry uses a simple IR representation that is built for the purpose of this compiler. The IR is a tree representation of the code, where each node represents an operation or a value. I could have also used LLVM IR as the intermediate representation, but the learning curve is steep, and I wanted to keep it simple. Doing so would actually have made the compiler more robust and powerful.

The IR would look something like this:

IR Structure: 
└── Root --> the root node of the IR
└── Function: Some("main") --> the main function
    └── BasicBlock: None --> the entry block of the function
        ├── Call: Some("printf") --> function call
        │   └── Constant: Some("\"Hello, World!\n\"") --> string literal
        └── Return: None --> return statement
            └── Constant: Some("0") --> return value

Industry Practice:

Modern compilers like LLVM, GCC, and .NET all use sophisticated IR systems:

LLVM IR is a portable, typed, assembly-like language
GCC uses GIMPLE and RTL as intermediate representations
JIT compilers typically use IR to enable fast compilation and optimization

Rust Language also uses LLVM IR as its intermediate representation. The Rust compiler (rustc) generates LLVM IR from the Rust source code, optimizes it, and then generates machine code for the target architecture.

GCC also uses a similar approach, generating an intermediate representation called GIMPLE, which is then optimized and translated into machine code.

Interpreters like Python and JavaScript engines (like V8) also use intermediate representations. For example, the V8 engine uses an intermediate representation called Ignition bytecode, which is a low-level representation of the JavaScript code that can be executed by the V8 engine.

Optimization

The generated IR is not always optimal. The optimization phase of the compiler improves the IR to make it more efficient. This can include removing dead code, inlining functions, and optimizing loops. The goal of optimization is to improve the performance of the generated code without changing its semantics.

Ferry uses the following optimizations:

Constant Folding and Propagation: Evaluates constant expressions at compile time and propagates constant values to reduce the number of calculations performed at runtime. For example, if a variable is assigned a constant value, that value can be propagated to other parts of the code.
Dead Code Elimination: Removes code that is never executed or has no effect on the program’s output. For example, if a variable is declared but never used, it can be removed from the IR.
Common Subexpression Elimination: Identifies and eliminates redundant calculations. For example, if the same expression is calculated multiple times, it can be stored in a temporary variable and reused.
Loop Optimizations: Improves the performance of loops by unrolling them, reducing the number of iterations, or optimizing the loop structure.

Ferry employs two types of optimizations:

Basic optimizations: Simple optimizations that doesn’t change the semantics of the code, like constant folding and dead code elimination.
Advanced optimizations: More complex optimizations that require a deeper understanding of the code structure like loop unrolling and function inlining.

Say our code looks like this:

int main(){
  int i = 0 + 2;
  for (i = 0; i < 10; i++)
  {
    if (i == 5)
      return 0;
  }
}

The optimizer should:

Evaluate the expression 0 + 2 at compile time and replace it with 2.
Stop the loop when i == 5 to avoid unnecessary iterations.
Remove the unnecessary assignment of i to 0 in the loop header.
Add a jump instruction to the loop header to avoid unnecessary iterations.
Optimize the loop to exit early when i == 5 by adding a return statement.

The IR could look like this:

IR Structure (Original):
└── Root
└── Function: Some("main")
    └── BasicBlock: None
        ├── BasicBlock: None
        │   ├── Alloca: Some("i")                           // Allocate space for variable 'i'
        │   └── Store: None                                 // Store initial value to 'i'
        │       ├── BinaryOp: Some("+")                     // Calculate 0+2
        │       │   ├── Constant: Some("0")                 // First operand
        │       │   └── Constant: Some("2")                 // Second operand
        │       └── Variable: Some("i")                     // Target variable
        └── BasicBlock: Some("for")
            ├── Store: None                                 // Loop initialization: i = 0
            │   ├── Constant: Some("0")                     // Value to store
            │   └── Variable: Some("i")                     // Target variable
            ├── BasicBlock: Some("for.header")              // Loop condition check
            │   └── BinaryOp: Some("<")                     // Compare i < 10
            │       ├── Load: None                          // Load value of 'i'
            │       │   └── Variable: Some("i")             // Variable to load
            │       └── Constant: Some("10")                // Upper bound
            └── Branch: None                                // Conditional branch
                ├── BinaryOp: Some("<")                     // Same comparison duplicated
                │   ├── Load: None                          // Load value of 'i' again
                │   │   └── Variable: Some("i")
                │   └── Constant: Some("10")
                └── BasicBlock: Some("for.body")            // Loop body
                    ├── BasicBlock: None                    // If statement block
                    │   └── Branch: None                    // Conditional branch
                    │       ├── BinaryOp: Some("==")        // Compare i == 5
                    │       │   ├── Load: None              // Load value of 'i'
                    │       │   │   └── Variable: Some("i")
                    │       │   └── Constant: Some("5")     // Value to compare against
                    │       └── Return: None                // Early return
                    │           └── Constant: Some("0")     // Return value
                    ├── BasicBlock: None                    // Loop increment block
                    │   ├── Load: None                      // Load value of 'i'
                    │   │   └── Variable: Some("i")
                    │   └── Store: None                     // Store i+1 back to i
                    │       ├── BinaryOp: Some("+")         // Calculate i+1
                    │       │   ├── Load: None              // Load value of 'i' again
                    │       │   │   └── Variable: Some("i")
                    │       │   └── Constant: Some("1")     // Increment by 1
                    │       └── Variable: Some("i")         // Target variable
                    └── Jump: Some("for.header")  // Unconditional jump to loop header

The basic optimizer would then optimize the IR using the following optimizations:

---------Starting Optimization---------
Optimization iteration 1
Folded binary op to constant: 2
Replaced load of i with constant None
Replaced load of i with constant None
Replaced load of i with constant None
Replaced load of i with constant None
Replaced load of i with constant None
CSE: Found duplicate expression: LOAD(VAR(i))
CSE: Found duplicate expression: LOAD(VAR(i))
Optimization iteration 2
Replaced load of i with constant None
Replaced load of i with constant None
Replaced load of i with constant None
CSE: Found duplicate expression: LOAD(VAR(i))
CSE: Found duplicate expression: LOAD(VAR(i))
Optimization iteration 3
Replaced load of i with constant None
Replaced load of i with constant None
Replaced load of i with constant None
CSE: Found duplicate expression: LOAD(VAR(i))
CSE: Found duplicate expression: LOAD(VAR(i))
Optimization iteration 4
Replaced load of i with constant None
Replaced load of i with constant None
Replaced load of i with constant None
CSE: Found duplicate expression: LOAD(VAR(i))
CSE: Found duplicate expression: LOAD(VAR(i))
Optimization iteration 5
Replaced load of i with constant None
Replaced load of i with constant None
Replaced load of i with constant None
CSE: Found duplicate expression: LOAD(VAR(i))
CSE: Found duplicate expression: LOAD(VAR(i))
Optimization complete after 5 iterations

and this is what the optimization would look like:

IR Structure:
└── Root
└── Function: Some("main")
    └── BasicBlock: None
        ├── BasicBlock: None
        │   ├── Alloca: Some("i")                          // Allocate space for variable 'i'
        │   └── Store: None                                // Store initial value to 'i'
        │       ├── Constant: Some("2")                    // OPTIMIZATION: Constant folding of 0+2 to 2
        │       └── Variable: Some("i")                    // Target variable
        └── BasicBlock: Some("for")
            ├── Store: None                                // Loop initialization: i = 0
            │   ├── Constant: Some("0")                    // Value to store
            │   └── Variable: Some("i")                    // Target variable
            ├── BasicBlock: Some("for.header")             // Loop condition check
            └── Branch: None                               // Conditional branch
                ├── BinaryOp: Some("<")                    // OPTIMIZATION: CSE - eliminated duplicate comparison
                │   ├── Load: None                         // OPTIMIZATION: Single load of 'i' (CSE applied)
                │   │   └── Variable: Some("i")  
                │   └── Constant: Some("10")
                └── BasicBlock: Some("for.body")
                    ├── BasicBlock: None
                    │   └── Branch: None
                    │       ├── BinaryOp: Some("==")       // Compare i == 5
                    │       │   ├── Load: None             // OPTIMIZATION: Single load of 'i' (CSE applied)
                    │       │   │   └── Variable: Some("i")
                    │       │   └── Constant: Some("5")
                    │       └── Return: None               // Early return
                    │           └── Constant: Some("0")
                    ├── BasicBlock: None
                    │   └── Store: None                    // OPTIMIZATION: Simplified increment
                    │       ├── BinaryOp: Some("+")
                    │       │   ├── Load: None             // OPTIMIZATION: Single load of 'i' (CSE applied)
                    │       │   │   └── Variable: Some("i")
                    │       │   └── Constant: Some("1")
                    │       └── Variable: Some("i")
                    └── Jump: Some("for.header")           // Loop back

While it correctly preserved the program’s structure and performed some basic optimizations like constant folding (0 + 2 → 2), it hasn’t performed the more advanced control flow analysis that would recognize this optimization opportunity. The advanced optimizer would then optimize the IR using the following optimizations:

---------Starting Advanced Optimization---------
Optimization iteration 1
Optimization iteration 2
Optimization complete after 2 iterations

----- Optimization Summary -----
Constants folded: 0
Dead code blocks removed: 2
Common expressions eliminated: 0
Loops optimized: 0
Functions optimized: 0
-------------------------------

and this is what the optimization would look like:

IR Structure (During Advanced Optimization):
└── Root
└── Function: Some("main")
    └── BasicBlock: None
        ├── Alloca: Some("i")                     // Allocate space for variable 'i'
        ├── Store: None                           // OPTIMIZATION: Eliminated dead store (i=2 never used)
        │   ├── Constant: Some("0")               // Store initial loop value directly
        │   └── Variable: Some("i")               // Target variable
        ├── BasicBlock: Some("loop_check")        // OPTIMIZATION: Simplified loop structure
        │   └── Branch: None                      // Conditional branch for both loop and early exit
        │       ├── BinaryOp: Some("==")          // OPTIMIZATION: Combined conditions - check i==5 directly
        │       │   ├── Load: None                // Load value of 'i'
        │       │   │   └── Variable: Some("i")
        │       │   └── Constant: Some("5")       // OPTIMIZATION: Early exit condition
        │       └── Return: None                  // Early return when i==5
        │           └── Constant: Some("0")       // Return value
        ├── Store: None                           // Increment i
        │   ├── BinaryOp: Some("+")               // Calculate i+1
        │   │   ├── Load: None                    // Load value of 'i'
        │   │   │   └── Variable: Some("i")
        │   │   └── Constant: Some("1")           // Increment by 1
        │   └── Variable: Some("i")               // Target variable
        └── Jump: Some("loop_check")              // OPTIMIZATION: Direct jump to loop check

and finally, the IR structure would look like this:

IR Structure:
└── Root
└── Function: Some("main")
    └── BasicBlock: None

and our original code in the final optimised version would look like this:

This optimizer has aggressively removed the dead code blocks and optimized the loops and correctly identified that the code always returns 0 and thus removed the entire loop! While our original code example in IR would look like this:

IR Structure:
└── Root
└── Function: Some("main")
    └── BasicBlock: None
        ├── Call: Some("printf")
        │   └── Constant: Some("\"Hello, World!\n\"")
        └── Return: None
            └── Constant: Some("0")

Sidenote:

And this, kids, is precisely why a similar code in C, C++, or Rust would be always be faster to run than in Python, Java, or JavaScript. The optimizations are done at the IR level, which is much closer to the machine code than the source code. All optimizations happen before the program runs, so there’s no runtime overhead for these analyses. Type information is available at compile time, enabling more powerful optimizations and eliminating runtime type checking.

In contrast, Interpreters typically analyze code line-by-line or function-by-function, missing many global optimization opportunities. Runtime type checking adds overhead and limits certain optimizations.

Although, there are JITs (Just-In-Time) compilers that compile the code at runtime, which can be faster than traditional interpreters. JITs use a combination of interpretation and compilation to optimize the code at runtime. But, even JIT compilers that optimize during execution have to balance optimization time against execution time. Features like dynamic dispatch, reflection, and metaprogramming make certain optimizations impossible. Modern JIT compilers (like in JavaScript engines) have narrowed the gap through techniques like type specialization and trace-based compilation, but they’re still constrained by the dynamic nature of these languages and the need to optimize during execution.

Code Generation

The final step would be generating Assembly code from the IR. The assembly code is a low-level representation of the program that can be assembled into machine code and is CPU-specific. The code generator traverses the IR and generates assembly code for each instruction. Here’s a RISC-V reference for the assembly code.

A short summary of the RISC-V ISA to understand the assembly code:

The codegenerator iterates over the generated IR and generates assembly code for each instruction. It traverses the IR tree and maps each node type to specific RISC-V instructions, and this isn’t a simple one-to-one mapping - it involves careful register allocation, stack management, and preserving calling conventions. Here’s how the process works:

IR Node → Register Allocation → Assembly Instructions → Function Prologue/Epilogue → Final Assembly

Call Node: For function calls, the code generator does the following:

Pushes temporary registers that might be modified by the call
Evaluates all argument expressions
Moves arguments to parameter registers (a0-a7)
Issues the “call” instruction
After the call, it restores temporary registers

Register Allocation: Incorporates a simple counter system (get_new_temp()) to allocate registers for temporary variables. It uses a stack-like approach to manage the registers, where the most recently allocated register is used first. For our “Hello, World!” program, the code generator would do the following:

The string constant gets placed in the .rodata section with a unique label
A temporary register (say t0) is loaded with the address of this string
This register is moved to a0 before the printf call
The return value 0 is loaded into a different register (like t1)
This register is moved to a0 before the return

Stack Management: Stack management is crucial for function calls. The code generator handles this by:

Function prologue that saves return address (ra) and frame pointer (s0)
Stack space allocation for local variables
Parameter passing using both registers and stack
Restoring saved registers in the epilogue

and the final compiled steps might look like this:

The string “Hello, World!\n” is placed in the .rodata section with a label like .LC0
The main function starts with a prologue to set up the stack frame
The address of .LC0 is loaded into a temporary register
This register is moved to a0 (first argument register)
The printf function is called
A constant 0 is loaded into a temporary register
This register is moved to a0 (return value register)
The epilogue restores saved registers and returns

IR Node: Call: Some("printf")
     ↓
Assembly: la t0, .LC0    # Load string address
          mv a0, t0      # Set first argument
          call printf    # Call the function

IR Node: Return: None → Constant: Some("0")
     ↓
Assembly: li t1, 0       # Load immediate value 0
          mv a0, t1      # Move to return register
          # Epilogue follows

and the final assembly code would look like this:

.section .data
.section .text
.global main

.extern printf
.global main

main:
    # Prologue
    addi sp, sp, -8
    sw ra, 4(sp)
    sw s0, 0(sp)
    addi s0, sp, 8

.section .rodata
.LC0:
    .string "Hello, World!\n"
.section .text
    la t0, .LC0
    mv a0, t0
    call printf
    li t1, 0
    mv a0, t1
    mv sp, s0
    addi sp, sp, -8
    lw ra, 4(sp)
    lw s0, 0(sp)
    addi sp, sp, 8
    ret

    # Epilogue
    lw ra, 4(sp)
    lw s0, 0(sp)
    addi sp, sp, 8
    ret

Assembly and Linking

The assembly code generated by Ferry is specific to the RISC-V architecture. It can be assembled into machine code using an external assembler like riscv64-unknown-elf-gcc and has to be linked with libc (C standard library) to create an executable binary. The assembly code is a low-level representation of the program that can be executed on a RISC-V CPU.

The process flows like this:

.s (Assembly code) --> Assembler --> .o (Object file) --> Linker --> Executable/ Machine code/ Binary

Ferry has a separate module that helps with the assembly and linking process. This is a separate binary that uses the riscv64-unknown-elf-as to assemble and riscv64-unknown-elf-gcc tools to assemble and link the code. It then uses spike to run the code. The module is called mac_os_runner and the binary is called runner.

cargo run --release --bin runner -- <input_file.s>

The complete process of compiling and running a C program using Ferry in an ARM64 environment is as follows:

cargo run --release --bin ferry -- <input_file.c>
cargo run --release --bin runner -- <input_file.s>

Here’s a simple instruction decoder for RISC-V machine code

Instruction decoder

This tool helps you decode RISCV32I instructions and convert them to their corresponding assembly code. (for example, 00000000000000000000000010000011 to lb x1, 0(x0))

Here is the standalone version of the tool: Barney- A RISC-V Instruction Decoder. This is going to be a handy tool to understand the instructions and their working. The tool will also include decoding assembly code to machine code in the future. (an assembler for RISC-V instructions)

Yatch

Yatch is a simple machine code interpreter for RISC-V. It can execute RISC-V assembly code directly, allowing you to run machine code directly on a simulated RISC-V CPU. Yatch was meant to show how CPUs read and execute instructions. Read everything about Yatch here.

Once you have the compiled assembly code, you can use a simulator like Yatch to simulate the execution of the code.

Future Work

Well, the current scope of Ferry was to understand and demonstrate the working of compilers. While I would love to finish this, there are far better, superior compilers out there. This article was a simple entry into how systems work. My next steps would be delving more into the world of compilers, optimising CPU operations, and GPU computing, and understanding the mechanics behind the scenes.

Also, a big big shoutout to my boy, Claude 3.7 sonnet for improving the compiler and helping ship it 10x faster. Such a complex task would have taken me weeks, or even months, to complete. Claude wrote lines of redundant code - the extra parsing methods, a couple of functionality implementations in advanced optimisations and type checker functions that would have taken me a lot of time to finish manually. Especially the advanced optimiser. That part was a pain to write and Claude handled it like a pro. You still need a decent Rust knowledge to be able to fix whatever an AI model returns, but it did an excellent job.

This article might seem overwhelming, but it’s pretty interesting to realize how all of modern computing works and see how far we’ve come.

Fourier Analysis

Anubhab Patnaik — Tue, 18 Nov 2025 00:00:00 GMT

Ever wondered how computers process and analyze images and shapes? You might have seen images stored as .png, .jpg, .bmp, or .svg while working with graphics or image processing. Broadly, image files can be represented using two fundamental formats: raster graphics and vector graphics.

Raster graphics store images as a grid of pixels, where each pixel contains color or intensity information.
Vector graphics represent shapes using mathematical equations — lines, curves, and polygons — allowing them to scale infinitely without losing quality.

Raster (JPG)

Vector (SVG)

In mathematical terms, an image in a two-dimensional space can be represented in two ways: spatial domain and frequency domain. In the spatial domain, the image is represented as a grid of pixels, where each pixel has a specific intensity value. In the frequency domain, the image is represented as a combination of different frequencies, which can be analyzed using Fourier analysis.

Fourier analysis is a mathematical technique used to decompose periodic functions into their constituent frequencies and analyze the amplitude and phase of each frequency component. Some of the key applications of Fourier analysis include audio processing, audio filtering, noise reduction, signal reconstruction, image compression, feature extraction, and recognition, object detection, and speech recognition among others. This means AirPods in your ears use some form of Fourier analysis to filter out the background noise when you activate noise cancellation in a subway or on a plane.

At its core, Fourier analysis is about decomposing a time-domain signal into its constituent frequencies, and inferring the amplitude and phase of each frequency component.

Draw a shape on the left canvas and watch Fourier epicycles trace it on the right! ^[1]

Left: Draw your shape | Right: Fourier epicycles tracing it

Recap
Fourier Series
- Periodic Signals
- Approximating Complex Waves with Fourier Series
Drawing with Fourier Series: Epicycles
Fast Fourier Transform (FFT)

Fourier Analysis

Instead of jumping straight into the math, I’ll try to build an intuitive understanding of how waves and signals work which would make it easier to grasp the need for Fourier analysis.

Here’s a quick overview recap on how waves and signals work, followed by an introduction to Fourier series, Fourier transform, and discrete Fourier transform.

Recap

A wave is a disturbance that travels through a medium, and a signal is a wave that carries information.

Sinusoidal Waves

The most fundamental wave pattern in nature is the sinusoidal wave (or sine wave). A sine wave is a smooth, continuous oscillation that repeats periodically. It’s described mathematically by the sine function, which produces a characteristic S-shaped curve when plotted.

The basic sine wave equation is:

$y = \sin(x)$

where $y$ oscillates smoothly between -1 and +1 as $x$ increases.

This simple mathematical function appears everywhere in nature—from the oscillation of a pendulum to the vibration of guitar strings, from alternating current in electrical circuits to the propagation of light and sound waves.

Sinusoidal waves are special because they are the building blocks of all other periodic waves. No matter how complex a wave pattern looks, it can be broken down into a sum of simple sine (and cosine) waves—this is the fundamental insight of Fourier analysis.

A Harmonic Wave:

Amplitude (A): 40

Frequency (f): 2 Hz

The equation $f(t) = A \sin(\omega t)$ represents a simple harmonic wave or oscillation with the following parameters:

Amplitude (A): The maximum displacement from the equilibrium position. It determines how “tall” the wave peaks are. In our example, $A = 40$ units.
Angular Frequency (ω): The rate of oscillation in radians per second. It is related to the frequency $f$ (in Hz) by the formula $\omega = 2\pi f$ . In our example, if $f = 2$ Hz, then $\omega = 4\pi$ radians per second.
Time (t): The independent variable, usually representing time in seconds.

Suppose we have a wave with frequency $f = 2$ Hz; the wave oscillates 2 times per second,

$T = \frac{1}{f} = \frac{1}{2} = 0.5$ seconds. (One cycle is completed in 0.5 seconds)
$\omega = 2\pi f = 2\pi \times 2 = 4\pi$ radians per second. (2 cycles are completed in 1 second)

The example equation $f(t) = 40 \sin(4\pi t)$ describes a wave with an amplitude of 40 units and a frequency of 2 Hz. This means the wave oscillates between -40 and +40 units, completing 2 full cycles every second.

This equation describes many periodic phenomena, such as a vibrating string, sound waves, light waves (for small angles in the wave equation), etc.

Functions of Waves and Signals

In mathematics, when we add two functions (say, $f(x)$ and $g(x)$ ) together), we simply add their output values at each input point. This is expressed as:

$(f + g)(x) = f(x) + g(x)$

This simple property of functions has profound implications in physics. When two waves occupy the same space simultaneously, they don’t collide or bounce off each other like physical objects. Instead, they superpose—their effects combine according to the principle of superposition.

The total displacement at any point is simply the sum of the individual wave displacements:

$y_{total}(t) = y_1(t) + y_2(t) + y_3(t) + ...$

Wave Interference

And this leads us to the fascinating phenomenon of wave interference.

Constructive Interference occurs when two waves are in phase (peaks align with peaks). Their amplitudes add together, creating a stronger wave:

$\sin(\omega t) + \sin(\omega t) = 2\sin(\omega t)$

For example, when two sound waves constructively interfere, they produce louder noise. In light waves, constructive interference creates bright spots on reflective surfaces.

Destructive Interference occurs when waves are out of phase (peaks align with troughs). They cancel each other out:

$\sin(\omega t) + \sin(\omega t + \pi) = 0$

This is the principle behind noise-cancelling headphones—they detect incoming sound waves and generate an exact opposite wave to cancel them out. When light waves destructively interfere, they appear as dim patches.

These wave behaviors demonstrate that mathematical function addition directly corresponds to physical wave superposition, bridging abstract mathematics with observable phenomena in our universe.

Wave 1 Amplitude: 30

Wave 1 Frequency: 1.5 Hz

Wave 2 Amplitude: 25

Wave 2 Frequency: 2.5 Hz

Now that we have a basic understanding of waves and signals, imagine being given a complex wave pattern, like a sound wave or an image signal, and being asked to figure out what simple sine and cosine waves make up that complex pattern. This is exactly where Fourier analysis comes in. Fourier analysis provides the mathematical tools to decompose complex signals into their constituent sine and cosine waves, allowing us to analyze the frequency content of the signal.

Complex Wave

→

Component 1

Component 2

This means when you record a sound using your phone, Fourier analysis can identify which low amplitude high-frequency signals are present in the complex sound wave, apply a 180-degree phase shift to them, and add them back to the original sound wave to cancel out the noise.

Fourier Series

The Fourier series is a powerful tool that represents any reasonable^[2] periodic function as a sum of sine and cosine waves with different frequencies, amplitudes, and phases.

Periodic Signals

For periodic signals (functions that repeat over time, with period T), a signal 𝑓(𝑡) can be written as a sum of sine and cosine terms:

$f(t) = a_0 + \sum_{n=1}^{\infty} a_n \cos(2\pi n f_0 t) + b_n \sin(2\pi n f_0 t)$

where $f_0$ is the fundamental frequency (the lowest frequency component), and $a_0$ , $a_n$ , and $b_n$ are the Fourier coefficients that determine the amplitude of each frequency component:

$a_n$ represents the amplitude of the cosine wave at frequency $n f_0$
$b_n$ represents the amplitude of the sine wave at frequency $n f_0$

Alternatively, this can be written in amplitude-phase form:

$f(t) = a_0 + \sum_{n=1}^{\infty} A_n \cos(2\pi n f_0 t + \phi_n)$

where $A_n = \sqrt{a_n^2 + b_n^2}$ is the amplitude and $\phi_n = \arctan(-b_n/a_n)$ is the phase of the $n$ -th harmonic component.

Sound waves are periodic signals, and the Fourier series can be used to decompose them into their constituent frequencies.

Approximating Complex Waves with Fourier Series

Fourier series can approximate any periodic function by summing up sine and cosine waves. The more terms we include in the series, the better our approximation becomes. With an infinite number of terms, we can perfectly reconstruct the original function. (In practice, we use a finite number of terms to get a good approximation.)

Let’s see this in action with a square wave - a function that abruptly alternates between +1 and -1:

Number of Terms (n): 5

━━ Target Wave (Square Wave)

━━ Fourier Approximation

As you increase the number of terms, notice how the red Fourier approximation gets closer to the gray target square wave. With just a few terms, we can already capture the general shape. With more terms, the approximation becomes remarkably accurate, though you’ll always see some overshoot at the discontinuities (known as the Gibbs phenomenon)—this happens because finite sums of smooth waves can’t perfectly match a jump discontinuity. Even functions with sharp corners and discontinuities can be represented as sums of smooth, continuous sine waves!

Drawing with Fourier Series: Epicycles

Coming back to recreating images using mechanical arms above, we can use Fourier series to break down complex 2D paths and use the same principles of wave decomposition to reconstruct them.

Sketches as Functions

When you draw a picture, your pen traces a path through 2D space. You go in two directions simultaneously: horizontally (x-axis) and vertically (y-axis). At any moment in time $t$ , your pen has:

An x-coordinate: $x(t)$
A y-coordinate: $y(t)$

This means any drawing can be represented as two separate functions of time - one tracking horizontal movement, the other tracking vertical movement.

Batman silhouette drawn as a continuous path

Just like we decomposed sound waves, we can analyze the path by separating it into two time-domain signals.

The path decomposed into x(t) and y(t) signals

Fourier Approximation of the Bat Silhouette

We have two functions now: $x(t)$ and $y(t)$ . Using Fourier series, we can approximate both functions as sums of sine and cosine waves. Which means, two sets of Fourier coefficients - one for $x(t)$ and one for $y(t)$ can be used to retrace the path of the drawing.

Number of Terms: 10

With just a few terms, we get a rough outline. As we increase the number of terms, the Fourier reconstruction gets closer and closer to the original bat silhouette.

Epicycles: Rotating Vectors

There are primarily two ways to represent coordinates in 2D space: Cartesian coordinates $(x, y)$ and Polar coordinates $(r, \theta)$ . In Cartesian coordinates, a point is defined by its horizontal (x) and vertical (y) distances from the origin; P(x, y). In Polar coordinates, a point is defined by its distance from the origin (radius $r$ ) and the angle ( $\theta$ ) it makes with the positive x-axis; P(r, θ).

Polar coordinates use trigonometric functions to relate to Cartesian coordinates: $x = r \cos(\theta)$ , $y = r \sin(\theta)$ . In the polar coordinates system, a point can be represented as a vector originating from the origin, with length $r$ and angle $\theta$ .

Look at this example of $\sin(t)$ represented as a rotating vector in the complex plane:

Sine wave represented as a rotating vector

Notice how the tip of the rotating vector traces out the sine wave over time. Similarly, a periodic function can be represented as a sum of rotating vectors (epicycles) in the complex plane. Attach an epicycle on the tip of another epicycle, and so on.

y(t) = 50·sin(ωt) + 30·sin(3ωt)

Complex Exponential Notation

Earlier, we wrote the Fourier Transform and DFT using separate sine and cosine terms. There’s a more elegant way to write this using Euler’s formula, which establishes a beautiful connection between exponentials and trigonometry:

$e^{i\theta} = \cos(\theta) + i\sin(\theta)$

This remarkable equation means a complex exponential represents a rotating vector in the complex plane. From this, we can derive:

$\cos(\theta) = \frac{e^{i\theta} + e^{-i\theta}}{2}$

$\sin(\theta) = \frac{e^{i\theta} - e^{-i\theta}}{2i}$

Why this matters: Instead of writing separate $A(\omega)\cos(\omega t) + B(\omega)\sin(\omega t)$ terms, we can combine them into a single complex exponential:

$F(\omega) = \int_{-\infty}^{\infty} f(t) e^{-i\omega t} dt$

This is the compact form of the Fourier Transform you’ll see in textbooks. It’s the same math as before, just written more concisely.

Similarly, the DFT can be written as:

$X[k] = \sum_{n=0}^{N-1} x[n] e^{-i2\pi nk/N}$

Now, coming back to the Fourier series representation of our drawing, we combine x and y into one complex signal:

$z(t) = x(t) + i y(t)$

Fourier coefficients can be expressed as:

$z(t) = \sum_{n=-\infty}^{\infty} c_n e^{i n \omega t}$

Each term $e^{i n \omega t}$ represents a rotating vector (an epicycle) at frequency $n$ . The magnitude $|c_n|$ gives the radius, and $\arg(c_n)$ gives the starting phase.

Each term in the Fourier series can be visualized as a circle rotating at a specific frequency. When you connect these circles end-to-end (placing the center of each circle at the tip of the previous one), their combined motion traces out your original drawing.

Rotating circles (epicycles) tracing a path

Computing Epicycles with the DFT

Your drawing is sampled at discrete pixel points—not a continuous mathematical curve. For such sampled periodic signals, we use the Discrete Fourier Transform (DFT) to extract the frequency components.

The DFT takes $N$ sampled points and computes $N$ frequency components, each with amplitude and phase:

$X[k] = \sum_{n=0}^{N-1} x[n] \, e^{-i2\pi nk/N}$

Each complex number $X[k]$ tells us:

Magnitude $|X[k]|$ : radius of epicycle $k$
Phase $\arg(X[k])$ : starting angle of epicycle $k$

Since our drawing is 2D, we combine $x$ and $y$ coordinates into one complex signal: $z[n] = x[n] + iy[n]$ . The DFT treats this closed path as one period of a repeating pattern—that’s why the epicycles loop perfectly!

Retracing our drawing with Epicycles

Summing up, we have:

A sketch
Decomposed into two time-domain signals: $x(t)$ and $y(t)$ , representing horizontal and vertical movement over time
Each horizontal and vertical signal approximated using Fourier series

Since your drawing is sampled at discrete points (not a continuous function), we use the Discrete Fourier Transform (DFT)—the sampled version of the Fourier transform.

Step 1: Analyzing the Drawing (DFT)

We compute complex coefficients $c_n$ by projecting the sampled path $(x_k + i y_k)$ onto each rotating basis $e^{-i2\pi nk/N}$ :

for (let n = -numFrequencies; n <= numFrequencies; n++) {
    let realSum = 0, imagSum = 0;

    for (let k = 0; k < N; k++) {
        const angle = (-2 * Math.PI * n * k) / N;
        realSum += x[k] * Math.cos(angle) - y[k] * Math.sin(angle);
        imagSum += x[k] * Math.sin(angle) + y[k] * Math.cos(angle);
    }

    // Convert to polar form: amplitude and phase
    amplitude = sqrt(realSum² + imagSum²) / N;
    phase = atan2(imagSum, realSum);
}

This gives us:

Amplitude: Radius of each rotating circle
Phase: Starting angle of each circle
Frequency: How fast each circle rotates

Step 2: Reconstructing the Path (Inverse DFT)

To redraw at time $t$ (from 0 to 1):

x(t) = Σ amplitude[n] * cos(2π * freq[n] * t + phase[n])
y(t) = Σ amplitude[n] * sin(2π * freq[n] * t + phase[n])

Each term is one rotating epicycle. Sum them all up to get the final pen position.

Step 3: Animation

for (t = 0; t < 1; t += 0.01) {
    position = evaluateEpicycles(coefficients, t);
    drawPoint(position.x, position.y);
}

As $t$ goes from 0 → 1, we complete one full cycle and trace the entire drawing!

Now, for each Fourier coefficient, we create an epicycle (rotating circle) in the complex plane. By connecting these epicycles tip-to-tail, the final tip traces out the original drawing.

Number of Epicycles: 40

More epicycles = better approximation

If you’ve followed this far, you’d have a fair understanding of how we used Fourier series to decompose a 2D drawing into two time-domain signals, approximated those signals using sine and cosine waves, and represented those waves as rotating vectors (epicycles) in the complex plane.

The Mathematics Behind Epicycles

For a closed curve sampled at $N$ points $(x_k, y_k)$ , we calculate the Fourier coefficients:

$c_n = \frac{1}{N} \sum_{k=0}^{N-1} (x_k + iy_k) e^{-2\pi i nk/N}$

Each coefficient $c_n$ can be converted to polar form:

Radius: $|c_n|$ (the size of the rotating circle)
Frequency: $n$ (how fast it rotates)
Phase: $\arg(c_n)$ (where it starts)

At any time $t$ , the position is:

$z(t) = \sum_{n=-M}^{M} c_n e^{2\pi int}$

where $M$ is the number of terms used in the approximation, and $z(t) = x(t) + iy(t)$ represents the pen’s position in the complex plane.

Why This Works

This technique works because:

Any periodic path can be approximated by summing sinusoids
Rotating vectors in the complex plane naturally create sinusoidal motion
Adding vectors tip-to-tail creates the epicycle visualization
The more terms we include, the closer we get to the original drawing

Generalizing: From Periodic to Non-Periodic Signals

So far, we’ve treated your drawing as a periodic signal—one complete cycle that the DFT assumes repeats infinitely. This is why closed curves work perfectly with epicycles.

But what about signals that truly don’t repeat? A recording of your voice, a single burst of noise, or any one-time event?

Fourier Transform for Non-Periodic Signals

The Fourier Transform generalizes the Fourier series to non-periodic signals. Instead of discrete harmonics (1×, 2×, 3× the fundamental frequency), we now have a continuous spectrum of all possible frequencies.

Using complex exponential notation, the Fourier Transform is:

Forward Transform (Signal → Frequency):

$F(\omega) = \int_{-\infty}^{\infty} f(t) e^{-i\omega t} \, dt$

Inverse Transform (Frequency → Signal):

$f(t) = \frac{1}{2\pi} \int_{-\infty}^{\infty} F(\omega) e^{i\omega t} \, d\omega$

where:

$f(t)$ is the time-domain signal
$F(\omega)$ is the frequency-domain representation (a complex number with amplitude and phase)
$\omega$ is the angular frequency

The Fourier Transform is essential for analyzing non-repeating signals in audio processing, image filtering, and countless other applications.

The DFT: Sampled and Periodic

The Discrete Fourier Transform (DFT) we used for drawings combines two properties:

Discrete: Works with sampled points (not continuous functions)
Periodic: Assumes the sample sequence repeats infinitely

For a sequence of $N$ samples $x[0], x[1], \ldots, x[N-1]$ :

$X[k] = \sum_{n=0}^{N-1} x[n] \, e^{-i2\pi nk/N}$

Inverse DFT (reconstructing the signal):

$x[n] = \frac{1}{N} \sum_{k=0}^{N-1} X[k] \, e^{i2\pi nk/N}$

Each $X[k]$ decomposes into:

Amplitude: $|X[k]| = \sqrt{A[k]^2 + B[k]^2}$
Phase: $\arg(X[k]) = \arctan(-B[k]/A[k])$

where $A[k]$ and $B[k]$ are the cosine and sine components.

The DFT is the foundation of all digital signal processing—analyzing digital audio, compressing images (JPEG), processing video, and more.

Fast Fourier Transform (FFT)

While our visualizations use the standard DFT algorithm shown above, real-world applications use a much faster algorithm called the Fast Fourier Transform (FFT).

The Performance Problem

The DFT we implemented has a critical limitation: computational complexity.

For a signal with $N$ points:

DFT complexity: $O(N^2)$ $O (N 2 )$ operations
- We loop through $N$ frequencies
- For each frequency, we sum over $N$ points
- Total: $N \times N = N^2$ operations

Example: For a 1-second audio clip at 44,100 Hz (CD quality):

$N = 44,100$ samples
DFT requires: $(44,100)^2 = 1.9$ billion operations
On a modern CPU: several seconds to compute

This is too slow for real-time applications like audio processing, video streaming, or live music visualizers.

Enter the FFT

In 1965, Cooley and Tukey rediscovered an algorithm (originally found by Gauss in 1805) that computes the exact same result as DFT, but much faster:

FFT complexity: $O(N \log N)$ operations

Same example (44,100 samples):

FFT requires: $44,100 \times \log_2(44,100) \approx 700,000$ operations
Speedup: 2,700× faster than DFT!
On a modern CPU: milliseconds instead of seconds

How FFT Works (Intuition)

The FFT uses a divide-and-conquer strategy:

Divide: Split the signal into even and odd indexed samples
Conquer: Recursively compute FFT on each half
Combine: Merge the results using clever math

The key insight: many of the calculations in DFT are redundant. The FFT eliminates this redundancy by reusing intermediate results.

// DFT: Computes everything from scratch
for (n in frequencies) {
    for (k in points) {
        // N² operations total
    }
}

// FFT: Divides work recursively
function FFT(points) {
    if (points.length === 1) return points;

    even = FFT(points[0, 2, 4, ...]);  // Recursion
    odd  = FFT(points[1, 3, 5, ...]);  // Recursion

    return combine(even, odd);  // N log N operations total
}

Performance deep dive:

For production systems, three details matter:

Power-of-two sizes: FFT is fastest when $N = 2^k$ (e.g., 512, 1024, 2048). This is because the divide-and-conquer splits evenly at each level. Non-power-of-two sizes work but require different algorithms (Bluestein’s, mixed-radix) that are slower.
Iterative vs recursive: The code above shows recursive FFT for clarity, but production libraries use iterative FFT (bit-reversal + in-place butterfly operations). Why? Recursive FFT has function call overhead and poor cache locality. Iterative FFT processes data in cache-friendly sequential passes.
Cache friendliness: Modern FFT implementations (like FFTW) use clever memory layouts and loop tiling to keep data in L1/L2 cache. A well-tuned FFT is often an order of magnitude faster in practice than a naive implementation, even with the same $O(N \log N)$ complexity.

This is why audio buffer sizes are always powers of two (256, 512, 1024)—it’s not arbitrary, it’s for FFT performance!

Why This Matters

DFT is great for:

Learning and understanding Fourier analysis
Small signals (< 1,000 points)
Our interactive visualizations

FFT is essential for:

Audio processing: Real-time effects, compression (MP3, AAC)
Image processing: JPEG compression, filters, Instagram effects
Video streaming: Netflix, YouTube use FFT for compression
Telecommunications: 4G/5G networks, WiFi
Medical imaging: MRI and CT scans
Scientific computing: Weather prediction, astronomy

Libraries and Implementation

Most programming languages provide optimized FFT libraries:

// JavaScript (using Web Audio API)
const fft = new FFT(bufferSize);
fft.forward(audioData);  // O(N log N) instead of O(N²)

// Python (NumPy)
import numpy as np
frequencies = np.fft.fft(signal)  // Uses FFTW library

// MATLAB
X = fft(x);  // Built-in FFT

These libraries use highly optimized implementations like FFTW (Fastest Fourier Transform in the West), which can be 100× faster than a naive FFT implementation.

Equipped with this you can now go on to explore the vast west of signal processing. This new weaponry can help you build something cool, like:

Implement noise reduction in sounds.
Sharpen images with denoising.
Create music visualizers that respond to audio frequencies.

This article including the image retracing is inspired from injuly’s fourier series blog. ↩︎
“Reasonable” functions are those that are piecewise continuous and have a finite number of discontinuities within a period. Not every periodic function is representable in a strong sense. There are periodic functions that are so pathological that: 1.the Fourier series fails to converge at some points, or even 2. diverges almost everywhere. These exist (classic results by du Bois-Reymond, later strengthened by others). You won’t meet them in engineering, but mathematically they kill the fully-general “any periodic function” claim. ↩︎

Conway's Game of Life

Anubhab Patnaik — Tue, 12 Nov 2024 00:00:00 GMT

Abstract machines and the computational universe

Automata theory is a branch of theoretical computer science that deals with abstract machines and the computational problems that can be solved using these machines. Automata are mathematical models of a machine that can perform certain computations. Essentialy, these are fundamental units of computation that can process input and produce output based on a set of rules. They are used to model and analyze computational systems, study the limits of computation, and explore the properties of formal languages(sets of strings of symbols that can be recognized by automata).

For example, this automaton can be thought of as a machine that processes input strings of 0s and 1s and produces an output based on a set of rules, such as:

$f: \{0, 1\}^* \rightarrow \{0, 1\}^*$

where $f$ is a function that takes an input string of $0$ s and $1$ s and produces an output string of $0$ s and $1$ s, based on the following rules:

If the input string contains an odd number of 1s, the output string should be 1.
If the input string contains an even number of 1s, the output string should be 0.

This automaton can be represented as a state machine, with states representing the number of 1s seen so far and transitions based on the input symbols. The machine starts in an initial state and transitions between states based on the input symbols, eventually reaching a final state that determines the output.

In simpler terms, think of it this way: an automaton is the smallest part of a machine that can operate independently and perform a specific task. Breaking this unit further would lead us nowhere, as it is the smallest indivisible part of a machine that can perform a computation. Like, a gearbox in a car is an automaton that performs the task of changing gears, and it can’t be broken down further into smaller parts that perform any meaningful task.

Conway’s Game of Life

Building on automata theory, cellular automata are computational systems used to model complex systems and nonlinear dynamics. They are made up of simple, identical units called cells that evolve in parallel at discrete time steps. The state of each cell is determined by the states of its neighbouring cells, and the cells update their states based on a set of rules. Cellular automata have been used to study a wide range of phenomena, including biological systems, physical processes, and social dynamics.

A fascinating aspect of cellular automata is their ability to exhibit complex and unpredictable behaviour from simple rules that mimic real-life population dynamics. Conway’s Game of Life is a simple cellular automaton devised by the British mathematician John Horton Conway in 1970. It is a zero-player game, meaning that its evolution is determined by its initial state, requiring no further input. One interacts with the Game of Life by creating an initial configuration and observing how it evolves. Specifically, the game explores how simple rules governing individual cells can lead to emergent complexity and patterns over time, including stable structures, oscillating patterns, and even patterns that exhibit motion.

A few rules govern the evolution of the game are as follows:

Any live cell with fewer than two live neighbours dies, as if by underpopulation.

-->

Any live cell with two or three live neighbours lives on to the next generation.

-->

Any live cell with more than three live neighbours dies, as if by overpopulation.

-->

Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

-->

The game is played on a two-dimensional grid of cells, each of which can be in one of two states: alive or dead. The game proceeds in discrete steps, with each step representing a generation of cells. At each step, the game applies the rules to each cell in the grid simultaneously, updating the grid to reflect the new state of each cell based on its current state and the states of its neighbours.

The Game of Life in Action

Grid

Speed

Generations: 0

To start, design your initial configuration by clicking on the cells to toggle their state. Once you’re ready, click the “Start/Stop” button to watch the game evolve. You can pause the game at any time by clicking the “Stop” button, and clear the grid by clicking the “Clear” button.

The speed of the game can be adjusted by changing the speed slider. The game will evolve at a faster pace as the slider is moved to the right. The grid slider can be used to adjust the size of the grid, allowing for larger or smaller configurations.

A Turing Complete Machine

This might seem cool; just a game, right? It’s more interesting than that. To explain why, I would have to make your brain hurt a little bit more.

Automata like these can be classified into two main categories: finite automata( finite states, finite memory) and infinite automata(infinite states, infinite memory). For example, a finite automaton can be used to recognize whether a given input string is a valid email address or a phone number(A regular expression). Infinite automata are more complex and powerful. For example, an infinite automaton can be used to recognize whether a given input string is a valid programming language statement or a mathematical expression. (Compilers and interpreters). Game of Life is a prime example of an infinite automaton, as it can simulate complex systems and exhibit infinite states from a fixed configuration.

Finite automata can be further classified into:

Deterministic Finite Automata (DFA): A determined outcome for a given input.
Non-Deterministic Finite Automata (NFA): Various outcomes for a given input.

However, both DFA and NFA:

Operate on a finite amount of memory (the states).
Can only make decisions based on the current state and the immediate input.
Cannot handle languages that require unbounded memory, like those involving nested structures or long-term dependencies.

To solve these issues, a Pushdown Automaton (PDA) was introduced. A PDA is an automaton with a stack that can store an unbounded amount of memory. It can push and pop symbols onto the stack, allowing it to handle context-free languages( languages that can be described by context-free grammar; languages powerful enough to describe many programming language constructs, such as nested structures (e.g., balanced parentheses, if-else blocks)) that require more complex memory access. Simply put, a PDA can recognize languages that a DFA or NFA cannot, making it a more powerful model of computation.

Bear with me, this useless information will make sense in a bit; I promise. The concepts of FSMs lay the groundwork for understanding why this cellular automaton is such a fascinating piece of work by this brilliant British mathematician.

However, a PDA still has limitations:

The stack provides memory, but it’s limited in structure (LIFO- Last in First Out).
It can’t handle languages requiring more general or unbounded memory access.

This led to the development of the Turing Machine, a theoretical model of computation that can simulate any algorithm or computation that can be performed by a digital computer. A Turing machine consists of an infinite tape divided into cells, a read/write head that can move left or right along the tape and a finite set of states. The machine can read the symbol on the current cell, write a new symbol, move the tape left or right, and change its state based on a set of rules.

Turing Machine is the pinnacle of computation, as it laid the foundation for modern computers and computational theory. It can, in theory, solve any computational problem that can be solved by a digital computer, making it a universal model of computation. Whatever we see today, from the smallest microcontroller to the most powerful supercomputers, satelite systems, and AI, all are based on the principles of the Turing Machine.

The Game of Life has been shown to be Turing complete, meaning it can simulate any computation that a Turing machine can perform, given the right initial conditions. Certain configurations in the Game of Life can be used to simulate logic gates, memory, and other components of a computer, demonstrating its computational universality and performing universal computation, making it a fascinating area of study for computer scientists and mathematicians alike. It has been studied extensively by computer scientists, mathematicians, and physicists, and has been used to explore a wide range of topics, including complexity theory, artificial life, and emergent behaviour.

Building A CPU in the Game of Life

Having come this far, let’s attempt to build a CPU in the Game of Life. A CPU essentially is built up of three main components:

ALU (Arithmetic Logic Unit): Performs arithmetic and logical operations on data.
Memory: Stores data and instructions that are currently being executed by the CPU.
Control Unit: Manages the CPU’s operations by directing data between the ALU, memory, and I/O devices.

Arithmetic Logic Unit

The ALU is responsible for performing arithmetic and logical operations on data. It consists of a number of logic gates, adders, and other components that work together to perform operations such as addition, subtraction, AND, OR, and NOT.

Adder Circuit

AND Gate

In addition, you can set up a glider collision that represents the addition of two binary values. Each glider can be thought of as representing a binary input (either 0 or 1). The gliders in this pattern are designed to approach each other from opposite directions. When two gliders collide, they interact to produce an output, which can be interpreted as the sum of the two inputs. This collision represents the addition of two binary values, with the output glider moving in a different direction depending on the inputs.

If only one glider is present (input 1 + 0 or 0 + 1), it moves through without a collision, representing a result of 1.
If two gliders collide (input 1 + 1), they create a predictable pattern that can represent the sum of these inputs, often leaving behind a specific “output” glider that can represent the result.

Similarly, An AND gate can be created by positioning still-life patterns (static configurations that do not change) to manipulate gliders. If both inputs are “1” (represented by gliders arriving simultenously), they will interact to produce an output.

If both gliders arrive at the interaction point simultaneously, they will interact in a way that produces a specific pattern, representing the output 1 for an AND operation.
If only one glider arrives, it will pass through or interact with other cells without producing the 1 pattern, representing an output of 0.

Memory Unit

Memory Unit stores data and instructions that are currently being executed by the CPU. It consists of registers, cache, and main memory. It is responsible for storing and retrieving data from memory locations.

Blinker

Memory Cell(1 block)

This configuration is a 3x3 blinker, which oscillates between two shapes in two generations. Its oscillation does not spread or decay, so it remains contained and stable in its oscillating state.

Memory can be represented by stable patterns that remain constant unless disturbed by an external glider or oscillator. Stable patterns like blocks act as “bits” that can be toggled on or off by gliders, representing data storage. These two states can represent binary values (0 and 1) in a very simplistic way, with each state encoding one bit of information depending on its phase. This stability in position and periodic change makes it suitable for acting as a memory cell, as it reliably returns to a known state every two generations.

Similarly, an external pattern could be designed to change or “write” to the memory cell, altering its oscillation phase to represent a different binary state.

Control Unit

The control unit manages the CPU’s operations by directing data between the ALU, memory, and I/O devices. It fetches and decodes instructions, then signals the ALU and memory to execute.

Control Unit

This pattern is designed to function as a control unit by leveraging the behavior of known oscillators and spaceships in the Game of Life to produce predictable and repeatable outcomes. The pattern includes configurations that will evolve into gliders, which are small patterns that move across the grid over successive generations. Gliders can be used to transmit information or interact with other patterns in the grid.

Glider gun

A glider gun is a configuration of cells that emits gliders at regular intervals. It can be used to create a clock signal that controls the timing of operations in the CPU.

Glider Gun

A single block here can represent ‘1’ and an empty cell can represent ‘0’. The glider gun emits gliders at regular intervals, which can be used to synchronize the operations of the CPU. These inputs can work with adders, logic gates, and memory cells to perform ALU operations, store data, and control the flow of information within the CPU.

A Fully Functional Computer

To build a fully functional computer, you would need to design and implement a wide range of components, including registers, multiplexers, and arithmetic logic units, and connect them to form a complete system. Some of the components you would need to build include:

ALU components:

Adders (Half and Full- they can be used to add binary numbers) ⏎
Logic Gates (AND, OR, NOT, XOR, etc.- they perform logical operations on binary inputs) ⏎
Multiplexers( MUX- they select one of many inputs and route it to the output, used to handle multiple data inputs and control signals)
Registers( they store data temporarily during processing and can be used to store intermediate results)

Memory components:

Flip-Flops (they store a single bit of data using feedback) ⏎
RAM (Random Access Memory- they store data that can be read and written to used for storing data and instructions specific to the program)
ROM (Read-Only Memory- they store data that can only be read from- used for storing fixed data and instructions that do not change)

Control Unit components:

Finite State Machines (FSM- they have a finite number of states and transition between states based on inputs) ⏎
Clock Signals (they provide a timing mechanism for the CPU, controlling the rate at which operations are performed- using glider guns) ⏎
Instruction Decoders (they interpret instructions and direct the flow of data within the CPU)

While it is theoretically possible to build a computer within the Game of Life, it is painstakingly complex and fun! It requires a deeper understanding of logic gates, instruction sets, implementing memory, and control units.

Building the CPU would take you to combine these components to carry out fully functional operations. It would be a fun and challenging project to undertake, requiring a deep understanding of digital logic and computer architecture. The Game of Life serves as a fascinating model of how complexity can arise from simplicity, providing insight into topics such as self-organization, emergence, and cellular automata theory.

Here’s an actual CPU built in the Game of Life by Nicholas Carlini. In this series of posts, he tries to explain how he built digital logic gates, multiplexers, and registers in the Game of Life. I would love to do this someday when NYU is not down my throat threatening to kick me out for not doing my assignments.

If you choose carefully enough, you can make an entire computer inside the game, powered entirely by little things running around based only on those same simple rules of what lives and what dies in the next generation. An entire computer that could, in theory, perform any calculation that your computer could. It’s an interesting mathematical diversion depicting Turing’s completeness, the chaos that arises from simple rules, and it just looks pretty."

- Reddit

Also, someone built a Game of Life inside a computer built on top of THE GAME OF LIFE!!

Docking Compilers

Anubhab Patnaik — Thu, 12 Dec 2024 00:00:00 GMT

This post is the first post in a series of posts on compilers and interpreters. The second post, The Ferryman, introduces compiling high-level languages into machine code instructions, and we attempt at building a working C compiler for RISC-V. This post will delve deeper into the next part; understanding how CPUs execute machine code instructions.

Hacktoberfest is a fantastic opportunity to dive into the world of open source, make meaningful contributions, and sharpen your dev skills. This year, I’m most excited about Yatch: a machine code interpreter for RISC-V written in C++.

Recap: A brief overview of how high-level languages are compiled into machine code.
- Machine Code: Compiled code that the CPU can execute.
Computer Architecture: Understanding the components of a computer system. Why are compilers CPU-specific, while interpreters are not?
- RISC-V ISA: A brief overview of the RISC-V ISA.
- Instruction decoder: A tool to decode RISC-V instructions.
Yatch: A machine code interpreter for RISC-V written in C++.
- Walkthrough: Compiling Yatch and executing instructions.
- Single Stage Pipeline: A simple interpretation of how CPUs execute instructions.
- Five-Stage Pipeline: A real simulation of how CPUs execute instructions.

Compiling High-Level Languages

#include <stdio.h>
int main(){
  printf("Hello, World!");
  return 0;
}

Here’s a brief overview of GCC would compile this program:

Preprocessing: The compiler processes the #include directive and includes the contents of the stdio.h header file into the program. It also handles macros and other preprocessor directives.

Preprocessed Code:

int main(){
  printf("Hello, World!");
  return 0;
}

Lexical Analysis: The compiler breaks the preprocessed code into tokens. It reads the program character by character and groups them into tokens like keywords, identifiers, literals, operators, and punctuation.

Tokens: int, main, (, ), {, printf, (, "Hello, World!", ), ;, return, 0, ;, }

Syntax Analysis: The compiler checks if the sequence of tokens follows the grammatical rules of C. It builds a parse tree (or abstract syntax tree) representing the program’s structure.

FunctionDefinition
├── ReturnType: int
├── FunctionName: main
├── Parameters: ( )
└── Body:
    ├── ExpressionStatement: printf("Hello, World!");
    └── ReturnStatement: return 0;

Semantic Analysis: The compiler checks the program for semantic correctness. This includes type checking, verifying that functions and variables are declared before use, and ensuring that operations are valid for the given data types.

printf is declared in stdio.h and is correctly used.
The string "Hello, World!" is a valid argument.
The main function correctly returns an integer.

Intermediate Code Generation: TThe compiler generates an intermediate representation (IR) of the program. GCC uses internal representations like GIMPLE and RTL.

// This is a simplified illustration
function main()
{
  tmp0 = "Hello, World!";
  call printf(tmp0);
  return 0;
}

Optimization: The compiler optimizes the intermediate code to improve performance. It may remove redundant code, simplify expressions, and reorder instructions.

function main()
{
  call printf("Hello, World!");
  return 0;
}

Code Generation: The compiler generates assembly code from the optimized intermediate code. This code is specific to the target CPU architecture.

Assembly Code (Simplified x86-64 Example):

    .section .rodata
.LC0:
    .string "Hello, World!"

    .text
    .globl main
main:
    push    %rbp
    mov     %rsp, %rbp
    lea     .LC0(%rip), %rdi
    call    puts
    mov     $0, %eax
    pop     %rbp
    ret

Assembly and Linking:

Assembly: The assembler converts the assembly code into object code (machine code in binary form).
Linking: The linker combines object code with libraries to produce the final executable.

For example, for the x86-64 architecture, the conversion in hexadecimal would look like:

# Data Section (.rodata):
01001000 01100101 01101100 01101100 01101111 00101100 00100000 01010111 01101111 01110010 01101100 01100100 00100001 00000000

# Text Section (.text):
01010101 01010101 01010101 01010101 : push %rbp
01001000 10001001 11100101 : mov %rsp, %rbp
01001000 10001101 00111101 **** **** **** **** : lea .LC0(%rip), %rdi
11101000 **** **** **** **** : call puts
10111000 00000000 00000000 00000000 00000000  : mov $0, %eax
01011101 : pop %rbp
11000011 : ret

GCC uses intermediate representations during compilation:

GIMPLE: A simplified, language-independent representation that makes it easier to perform optimizations.
RTL (Register Transfer Language): A lower-level representation closer to assembly, used for target-specific optimizations and code generation.

While, interpreters translate and execute the program line by line. The interpreter:

reads the source code line by line,
translates it into machine code (or bytecode in HLLs),
translates bytecode into machine code and runs it in a virtual machine.

This allows for dynamic typing, interactive debugging, and easier integration with other languages. However, interpreters are generally slower than compilers because they don’t optimize the entire program before execution.

I will finish up a detailed post on a C compiler soon. This post is an intriduction to the next part of the series, a machine code interpreter for RISC-V.

Machine Code

The above generated binary code is run as instructions on the CPU. The CPU executes these instructions in a sequence, and the program runs. The CPU has a set of instructions it can execute, known as the instruction set architecture (ISA). The ISA defines the instructions the CPU can execute, the registers it uses, and the memory model it follows. For example, an instruction might look like 00000000000000000000000010000011, which translates to lb x1, 0(x0) in RISC-V assembly. This instruction, specific to the RISC-V ISA, loads a byte from memory into register x1.

Computer Architecture

The following post explores machine code instructions and the RISC-V ISA, a popular open-source instruction set architecture. We try to see how a RISC-V CPU would execute machine code instructions using Yatch, a machine code interpreter written in C++.

RISC-V ISA

RISC-V is an open-source instruction set architecture (ISA) based on established reduced instruction set computing (RISC) principles. Here is the complete ISA: RISC-V IS Table.

The base ISA consists of approximately 40 instructions, and this project aims to implement most of them. Other instructions sets are extensions to the base ISA, and we might explore them later.

Here is a summary of the base ISA instructions:

Load/Store: Load and store instructions to move data between memory and registers.
Arithmetic/Logical: Arithmetic and logical operations on registers.
Control Transfer: Branch and jump instructions to control program flow.
Immediate: Instructions that use an immediate value.
System: Instructions for system calls and other privileged operations.

The instructions are divided into six categories based on their operation:

R: Register-Register Operations (ADD, SUB, AND, OR, XOR, etc.)
I: Immediate Operations (ADDI, SLTI, SLTIU, XORI, ORI, ANDI, etc.)
S: Store Operations (SW, SH, SB)
B: Branch Operations (BEQ, BNE, BLT, BGE, BLTU, BGEU)
U: Upper Immediate Operations (LUI, AUIPC)
J: Jump Operations (JAL, JALR)

A short summary of the RISC-V Card:

Instruction decoder

Before moving on to the implementation, here’s a small tool that would aid in your understanding of instructions and their working. This tool helps you decode RISCV32I instructions and convert them to their corresponding assembly code. (for example, 00000000000000000000000010000011 to lb x1, 0(x0))

Yatch

Yatch is a machine code interpreter for RISC-V written in C++. The project aims to provide a basic understanding of how CPUs execute instructions and the principles of pipelining.

To get started with Yatch, you need a C++ compiler. You can use g++ or clang++ to compile the code.

Compile and run the code using the following commands:

$ g++ -std=c++20 -o yatch src/main.cpp
$ ./yatch src/io

Walkthrough

The process of executing instructions is divided into five stages:

IF: Instruction Fetch
ID: Instruction Decode
EX: Execution
MEM: Memory Access
WB: Write Back

The main code runs in a loop, it keeps processing instructions until either it encounters a HALT instruction or reaches the end of the program. The interpreter has two main “pipelines” for executing instructions:

The single stage pipeline is used for a simple interpretation of how CPUs execute instructions, and is not actively used in the current implementation. It helps understand the basic principles and builds a foundation for the more complex pipeline.

1. Single Stage Pipeline:

One instruction is executed at a time. The interpreter fetches the instruction, decodes it, executes it, accesses memory, and writes back the result in a single cycle, repeats the process for the next instruction.

Example: (instruction in memory)

00000000 00000000 00000000 10000011

(data in memory)

01010101 01010101 01010101 01010101

This instruction translates to lb x1, 0(x0) in RISC-V assembly. It loads a byte from memory into register x1. The instruction is executed in the following stages:

Instruction Fetch (IF): The interpreter fetches the instruction from memory. A program counter (PC) keeps track of the current instruction. An instruction in RISC-V is 32 bits long. Yatch stores the instructions in memory as an array of 8-bit integers.
```
while (getline(imem, line)){
 IMem[i] = bitset<8>(line);
 i++;
}
....
bitset<32> instruction;
for (int i = 0; i < 4; ++i){
instruction <<= 8; // Shift left by 8 bits to make room for the next byte
instruction |= bitset<32>(IMem[address + i].to_ulong()); // Combine the next byte
// 00000000 00000000 00000000 10000011
}

return instruction;
....
```
The reason why Yatch stores instructions in memory as an array of 8-bit integers and not 32-bit integers is that the instructions are read from a file, and each line in the file is 8-bits long. However, future implementations might change this.

The program counter (PC) increases by 4 bytes (32 bits) after each instruction.
Instruction Decode (ID): The instruction is decoded and the opcode and operands are extracted. Now, based on the opcode, the interpreter knows which instruction to execute.
- Opcode (bits 0-6): 0000011 - This is a Load instruction.
- Funct3 (bits 12-14): 000 - Specifies the type of load, which is LB (Load Byte).
- Destination Register (rd) (bits 7-11): 00001 - Register x1.
- Source Register (rs1) (bits 15-19): 00000 - Register x0.
- Immediate (bits 20-31): 000000000000 - Immediate value 0.

Execution (EX): The instruction is executed according to the specific case. For the lb, the interpreter reads the byte from memory and stores it in the destination register.

switch (opcode){
    case 0x33:{ // R-type instructions
    switch (funct3){
        case 0x0:
        if (funct7 == 0x00){
 result = bitset<32>(myRF.readRF(rs1).to_ulong() + myRF.readRF(rs2).to_ulong()); // ADD
            } else if (funct7 == 0x20){
 // SUB
.....

    case 0x03:{ // I-type instructions
    switch (funct3){
        case 0x0:
 // LB
 result = bitset<32>(myRF.readRF(rs1).to_ulong() + imm.to_ulong());
        break;
    }
}

Memory Access (MEM): Yatch reads the memory from a file and uses an 8-bit array to store the memory. It further uses specific functions to read specific memory locations.
```
while (getline(dmem, line)){
 DMem[i] = bitset<8>(line);
 i++;
}
....
bitset<8> readByte(uint32_t address){
    if (address < DMem.size())
    return DMem[address];
    else {
        throw runtime_error("Read Byte Error: Address out of bounds."); // Handle out-of-bounds access
        return bitset<8>(0);
    }
}
```
The opcode in the example is 0000011, I type the instruction, corresponding to the load instruction. Funct3 is 000, corresponding to the lb instruction. The lb instruction loads a byte from memory into a register. Similarly, a different funct3, for ex. 010 would correspond to the lw instruction, which loads a word from memory into a register. The primary step is to switch on the opcode and execute the corresponding instruction.

Memory is handled using registers. Yatch uses a 32-bit vector to store 32 registers. The instruction loads a byte from memory at the address calculated by adding the immediate offset 0 to the value in register x0 (0). The data in the 0th memory location(01010101) is read and stored in the destination register.

Write Back (WB): The result of the operation is written back to the register file.

Registers. resize(32); // 32 registers in total, each 32 bits wide
Registers[0] = bitset<32>(0); // Register x0 is always 0 in RISC-V

bitset<32> readRF(bitset<5> Reg_addr){
    uint32_t reg_index = Reg_addr.to_ulong(); // Converts Reg_addr to integer for indexing
    return Registers[reg_index]; // Returns the register value at the given index
}   

void writeRF(bitset<5> Reg_addr, bitset<32> Wrt_reg_data){
    uint32_t reg_index = Reg_addr.to_ulong(); // Converts Reg_addr to integer for indexing
    if (reg_index != 0) Registers[reg_index] = Wrt_reg_data; // Write the data to the register

    else throw runtime_error("Cannot write to register x0.");   
}

Once all the instructions are executed, the memory is written back to a file.

This entire journey is completed in a single cycle. This serves as a good simulator for understanding how CPUs execute instructions, but the real-world compute requires a more complex pipeline, parallel processing; and multiple instructions executed simultaneously.

2. Five-Stage Pipeline:

A single program has millions of instructions, and executing them one by one would take a lot of time. This pipeline allows the CPU to execute multiple instructions simultaneously, improving the overall performance.

The pipeline is divided into five stages: IF, ID, EX, MEM, and WB. Each stage is responsible for a specific action. The main loop calls these functions in reverse order, starting with the WB stage and ending with the IF stage.

The reverse order achieves to handle hazards. There are three types of hazards: data hazards, structural hazards, and control hazards.

Data hazards occur when instructions that exhibit data dependence modify data in different stages of a pipeline. Ignoring potential data hazards can result in race conditions. Following are the types of data hazards:
- read after write (RAW), a true dependency: A read after write (RAW) data hazard refers to a situation where an instruction refers to a result that has not yet been calculated or retrieved. This can occur because even though an instruction is executed after a prior instruction, the prior instruction has been processed only partly through the pipeline. For example:
```
  i1. **R2** <- R5 + R8
  i2. R4 <- **R2** + R8
```
- write after read (WAR), an anti-dependency: A write after read (WAR) data hazard refers to a situation where an instruction writes to a register that another instruction reads from. This can occur because the instruction that writes to the register is executed before the instruction that reads from the register. For example:
```
  i1. R4 <- **R2** + R8
  i2. **R2** <- R5 + R8
```
- write after write (WAW), an output dependency: A write after write (WAW) data hazard may occur in a concurrent execution environment. It refers to a situation where two instructions are written to the same register. For example:
```
  i1. **R5** <- R4 + R7
  i2. **R5** <- R1 + R3
```
Structural hazards: A structural hazard occurs when two instructions need the same hardware resource at the same time. For example, two instructions need to access the memory at the same time.
Control hazards: A control hazard occurs when the pipeline makes the wrong decision on a branch instruction. The pipeline must be flushed, and the correct instructions must be fetched.

This pipeline is designed to handle control hazards and data hazards. The pipeline initializes the PC, and all the stages except the IF stage are set to NOP (no operation). The IF stage fetches the first instruction from memory and sets the PC to the next instruction.

Example: (instruction in memory)

00000000 00000000 00000000 10000011

(data in memory)

01010101 01010101 01010101 01010101

The main loop calls these functions in reverse order, in the following sequence:

// Initialize pipeline stages to nop
  state.IF.nop = false;
  state.ID.nop = true;
  state.EX.nop = true;
  state.MEM.nop = true;
  state.WB.nop = true;

  // Initialize PC to 0
  state.IF.PC = bitset<32>(0);

WB: Write Back: Checks if the instruction has a destination register and writes the result back to the register file.
```
/* --------------------- WB stage --------------------- */
if (!state.WB.nop){ // Check if the instruction is not a NOP
  if (state.WB.wrt_enable){ // Write back to register file
    if (state.WB.Wrt_reg_addr.to_ulong() != 0) // x0 is always zero. Cannot override
 myRF.writeRF(state.WB.Wrt_reg_addr.to_ulong(), state.WB.Wrt_data); // Write the data to the register
  }
}
```
In the first step, this stage is set as a NOP. In the subsequent steps, the IF stage fetches the instruction from memory and sets the PC to the next instruction. Once the instruction is fetched, the ID stage decodes the instruction and extracts the opcode and operands. The EX stage executes the instruction, and the MEM stage reads or writes data to memory. Finally, the WB stage writes the result back to the register file. The loop continues until the end of the program. (All the stages are NOP)

MEM: Memory Access: Reads or writes data to memory.

  if (state.MEM.rd_mem)
  {
// Load from memory based on MemOp
    uint32_t address = state.MEM.ALUresult.to_ulong(); // Address to read from 
bitset<32> memData; // Data read from memory

    switch (state.MEM.mem_op) // Check the memory operation
    {
    case MemLB: // Load Byte
    {
bitset<8> data = ext_dmem.readByte(address); // Read a byte from memory
      int8_t signed_data = (int8_t)data.to_ulong(); // Convert to signed data
memData = bitset<32>(signed_data); // Store the data in a 32-bit bitset
 ......
  else nextState.WB.Wrt_data = state.MEM.ALUresult; // No memory operation, pass the ALU result to the WB stage.
}
else
nextState.WB.nop = true; // If MEM stage is nop, so WB stage is also nop

In the example, the instruction is a load instruction, so the MEM stage reads data from memory. The data is then passed to the WB stage. The MEM stage also checks if the instruction is a load or store instruction and reads or writes data to memory accordingly. Here,

bitset<32> memData = ext_dmem.readByte(address); // Read a byte from memory

The ALU result is the address of the memory location to read from. The data is then passed on from the ID stage.

EX: Execution: Executes the instruction. The instruction, decoded in the ID stage, is executed here.

if (!state.EX.nop)
{
// Perform ALU operations
bitset<32> operand1 = state.EX.Read_data1; // First operand
bitset<32> operand2 = state.EX.is_I_type ? state.EX.Imm: state.EX.Read_data2; // Second operand

// Forwarding from MEM stage
  if (state.MEM.wrt_enable && state.MEM.Wrt_reg_addr.to_ulong() != 0){ // Handles data hazards
    if (state.MEM.Wrt_reg_addr == state.EX.Rs)
operand1 = state.MEM.ALUresult; // Forward data from MEM stage to operand1
    
 .......
  switch (state.EX.alu_op) // perform ALU operation based on the ALU control signal
  {
  case ADDU:
ALUresult = bitset<32>(operand1.to_ulong() + operand2.to_ulong());
    break;
  case SUBU:
ALUresult = bitset<32>(operand1.to_ulong() - operand2.to_ulong());
    break;
  case AND:
ALUresult = bitset<32>(operand1.to_ulong() & operand2.to_ulong());
    break;
 .....

The ALU result is calculated based on the opcode and funct3 fields. The result is then passed on to the MEM stage. Our example instruction is a load instruction, so the ALU result is the address of the memory location to read from. The data is then passed on from the ID stage.

ALUresult = bitset<32>(operand1.to_ulong() + operand2.to_ulong()); // calculates the address to read from

ID: Instruction Decode: Decodes the instruction and extracts the opcode and operands.

if (!state.ID.nop){
bitset<32> instruction = state.ID.Instr;
// Decode instruction
  uint32_t instr = instruction.to_ulong();
  if (instr == 0xFFFFFFFF)
	  {
		  // HALT instruction encountered
		  state.IF.nop = true;		 // Stop fetching new instructions
		  nextState.IF.nop = true; // Stop fetching new instructions
	  }
	  else{
    uint32_t opcode = instr & 0x7F;
    uint32_t rd = (instr >> 7) & 0x1F;
    uint32_t funct3 = (instr >> 12) & 0x7;
    uint32_t rs1 = (instr >> 15) & 0x1F;
    uint32_t rs2 = (instr >> 20) & 0x1F;  
    uint32_t funct7 = (instr >> 25) & 0x7F;
// Hazard Detection
    bool stall = false; // Flag to indicate a stall is required
// Check for RAW hazards with EX stage
    if (state.EX.rd_mem && state.EX.Wrt_reg_addr.to_ulong() != 0){ // checks if the instruction in EX stage is a load instr and that the writeback register is not x0
      if (state.EX.Wrt_reg_addr.to_ulong() == rs1 || state.EX.Wrt_reg_addr.to_ulong() == rs2) stall = true; // Stall required
  // handles hazards here
 ...
    if (stall){
nextState.ID = state.ID; // Keep the instruction in the ID stage
nextState.EX.nop = true; // Insert nop in EX stage
nextState.IF = state.IF; // IF stage also needs to stall
// stall helps the EX stage to finish the operation before the ID stage reads the value
    }
    else{
// Prepare data for EX stage
nextState.EX.nop = false;
nextState.EX.Read_data1 = Read_data1;
nextState.EX.Read_data2 = Read_data2;
nextState.EX.Rs = rs1;
nextState.EX.Rt = rs2;
nextState.EX.Wrt_reg_addr = rd;
nextState.EX.Imm = bitset<32>(signExtendImmediate(instr));

// Set control signals based on opcode
      setControlSignals(opcode, funct3, funct7, nextState.EX); // sets the controls for the EX stage to execute the instruction based on the control signals

// Branch Handling
      if (opcode == 0x63) // Branch instructions
      {
 .....

In the example, the instruction is a load instruction, so the ID stage decodes the instruction and extracts the opcode and operands. The ID stage also checks for hazards with the EX stage. If a hazard is detected, the ID stage stalls and waits for the EX stage to finish the operation before reading the value. The ID stage then prepares the data for the EX stage and sets the control signals based on the opcode.

The 0xFFFFFFFF instruction is a placeholder for the HALT instruction. The HALT instruction stops fetching new instructions and halts the program. ID is responsible for HALT detection and handling.

IF: Instruction Fetch: Fetches the instruction from memory.

if (!state.IF.nop){
// Fetch instruction from instruction memory
bitset<32> instruction = ext_imem.readInstr(state.IF.PC);
// Prepare data for ID stage
nextState.ID.nop = false;
nextState.ID.Instr = instruction;
nextState.ID.PC = state.IF.PC;
// Update PC
nextState.IF.PC = bitset<32>(state.IF.PC.to_ulong() + 4); // Fetches the next instruction
}
else
nextState.ID.nop = true; // IF stage is nop, so ID stage is also nop

The IF stage fetches the instruction from memory and sets the PC to the next instruction. The instruction is then passed on to the ID stage. The PC is updated to fetch the next instruction.

Conclusion

While a five-stage pipeline is a correct and realistic representation for many simple RISC-V processors, more advanced implementations can have more stages and additional complexities. The five-stage model remains an effective starting point for understanding pipelining principles and serves as a foundation for more advanced pipeline structures in modern processors.

Jajabara (I)

Anubhab Patnaik — Sat, 10 May 2025 00:00:00 GMT

Greek mythology is fascinating and full of stories that explore the human condition. My fascination stems from the fact that even gods are flawed - subject to the same emotions and desires as mortals. Zeus is known for his numerous affairs and impulsive decisions, while Hera is often portrayed as jealous and vengeful. Aphhrodite embodies the complexities of love and desire, often leading to chaos and conflict. All divine, yet deeply imperfect.

Sisyphus, the king of Ephyra, was punished by Zeus for cheating death twice. He was condemned to roll a boulder up a hill, only to watch it roll back down, doomed to repeat this task for eternity, never able to complete it. I see the myth of Sisyphus as a metaphor for the futility of life and the eternal journey to find purpose in a world that is indifferent to our existence; a never-ending quest, a journey fraught with constant change and uncertainty. My journey throughout these years feels quite similar. Not because I am being punished by Zeus for cheating death (not that I’d get caught), but because I find myself constantly building a new life in a new corner of the world, pushing a new boulder up a new hill.

Each journey represents a new beginning, a fresh start in a different city, where I build a new life and make new friends. The ascent is filled with hope and possibility. I try to find my place in this newfound world and craft memories before the boulder rolls back down. Signalling the inevitable need to move, leaving behind what I’ve built and starting afresh. Empty houses—ones filled with laughter and joy, shops that let me pay later since I was a regular, now closed, replaced with malls and supermarkets, friends and their stories now only in distant memories, neighbours who became family, and friends who became strangers.

Bhubaneswar: The Early Years

My earliest memories are rooted in Bhubaneswar when I was around two or three years old- dating back to how my room looked, the faint essence of my bed, the tube lights and going to school. My mother’s image isn’t vivid - just fragments of her hair, a white dress, and the stories she told when getting me to sleep. We had an oval mirror in our room, and my faintest memories are looking at her getting ready. She took me everywhere with her, mostly to meet her friends and to her home. I do not remember the fragrance of her perfume, but I remember that I used to love her applying powder on my face.

My father had a Suzuki Max 100. We used to go out on rides, to the beach with his friends, and to places to eat. My parents are foodies, and I was a child who refused to eat anything. I always had this inexplicable urge to sit on the fuel tank. The “shotgun” equivalent of a motorcycle. It makes you feel like a rider, the man in control. My father used to let me sit there, and I remember the wind hitting my face and the thrill of the ride. I loved it. I still do. But now, as an adult, I see how that feeling of control is an illusion. At twenty-five, I see how I wouldn’t want to be the man in control, given a choice. Adulting is hard.

The lucid memories of faint incense sticks, the snug bed I slept in, and the blue tricycle I rode all feel like a different lifetime now, pieces of a world I left behind every time we moved.

Blue, because I remember it was blue, and my cousin-sister had a red one, but she somehow managed to break hers. Our mothers asked us to share the one I had. Sly, that one. Always knew right from wrong, sporting devilish smirks, with a knack for breaking things—chewed, scratched, or demolished in forms beyond recognition. We were colour-coded. All my things, from my tiffin and a huge water bottle to my pencils, were blue. Hers were red.

We are six months apart. Every day, our mothers would pick us up from school, and once we were home, they’d make us sit on the floor for lunch. For reasons I still don’t fully understand, I always took an absurdly long time to finish my meal—it could stretch anywhere from one to three hours. The afternoon naps were floaty and euphoric. We had this incredible Sony music system, and both followed a routine. The same music CD played every afternoon, and we were asleep by the end of the second song. That’s why I could only remember the first couple of songs on the CD, and one of them was Jajabara.

Similar to Sisyphus, Jajabara is a poem about a nomadic lifestyle, with the poet describing his journey through the world, and the world being a stage. The poet refers to their mind as a nomad who constantly roams or seeks something beyond immediate reality. It speaks about the poet’s limitless hopes and indicates a deep longing or an unquenchable thirst for something greater, a cyclical nature of life where values or rules are constantly created and discarded like sandcastles, highlighting the transient, Sisyphean nature of human beliefs. The twenty-five-year-old me relates to it now, the nomadic lifestyle, the constant search for meaning, and the Sisyphean journey of life.

My cousin, who once a child breaking her red tricycle, got married last month. We started as children with colour-coded possessions, and now she is building her own family while I build a career across the ocean in the opposite part of the globe. Strange how nostalgia grips you.

My Sisyphean journey began when my father was transferred from Bhubaneswar to Kolkata in 2005. Each time we packed up and left, I saw the boulder rolling back down. We started building a new life in a different city. The cycle of moving and rebuilding continued, each time leaving behind a piece of myself. Exploring new places and thinking more about the purpose of life.

Tram Rides and Power Rangers

Leaving behind my grandparents and family was the most difficult. Each of my grandparents had lived for over half a century, carrying a treasury of experiences, perspectives, and philosophies that I loved to listen to. My maternal grandfather worked in the Secretariat, Odisha, while my paternal grandfather had been working in the education department in Odisha. Both of my grandmothers were teachers, though my father’s mother left her profession after marriage, while my mother’s mother continued teaching. Their stories weren’t just simple fables but windows into worlds shaped by time and wisdom. Years later, now that I think of it, the stories make me understand human psychology better. Each scrutinising from their own lens of how the world worked, right or wrong, they were mere perspectives which I seemed to absorb and live through. A time when crossing rivers to attend school and fishing for lunch was the norm. As a child, I was oblivious to the weight of their words, but now, as an adult, I see how their shoes fit me. Leaving my family was the hardest part of moving.

We moved to Kolkata in 2005 when my father’s job took us there. We lived in the company’s quarters in Tollygunge, a small, close-knit space with a single bedroom with an attached balcony that quickly became our new home. Our apartment was on the fourth floor, and the balcony overlooked the entire Kolkata. The colony had just two modest buildings, side by side, separated by a narrow passage that led to a small backyard. At the end of this passage, tucked against the wall, was a bench where you could sit and feel the world slow down. One side was flanked by the buildings, the other by a tall barrier that seemed to enclose our little world.

We couldn’t roam around on our bikes as freely as we used to; the streets of Kolkata felt too busy, the city too vast for us. Luckily, the main road I lived on had a tram stop near the mosque. Trams were slow enough to be safe, yet fascinating enough for me to hang my head out of the window. I remember how the ticket looked, the old paper with a red border, and the sounds of the bells; the bus conductor used to pull a rope tied to the roof, which was connected to a bell. Slowly settling into the busy, loud Kolkata life, the tram rides were a welcome respite, a chance to slow down and watch the world pass by.

A mosque was situated in the middle of the road. I used to figure out play time by listening to the azaan. Four-thirty in the afternoon marked the time for me to rush out and play. The other side of the road was a sweet shop. This one was responsible for sharing all our love with our relatives who came to visit, or the friends and family whom we visited. This shop embodied the essence of Kolkata’s culture.

Kolkata was kind and homely to us. The streets buzzed with busy life, clattering trams, honking yellow taxis, and the vibrant hum of people filling every corner. The smells of street food, especially sweet shops mixed with the scent of incense from nearby temples, and the narrow lanes wound through neighbourhoods like veins through the heart of the city, each turn leading to a different world. It was a world much bigger than what we were used to. The transition was already difficult for us Odias, as we did not understand Bengali, and Kolkata was adamant about making us learn it.

We explored the city mostly by metro, and a trip to a station sparked an odd obsession in me—the escalators. I couldn’t resist them. I’d race up and down in the same one-way belt, completely captivated, much to my father’s chagrin. In those days, corporal punishment was a common disciplinary response to disobedience, and each time I ran wild on the escalator and fell down, every time, I knew what awaited me next. Still, I couldn’t resist the pull of the moving stairs. I had to try and see if I could walk upstairs faster than the escalator moving down. I never could. It’s only now, decades later, that I see how that simple childhood struggle foretold a pattern in my life.

Initially, due to a shift in the middle of an academic year, I was enrolled in a girls’ school, which was a nightmare. Including me, there were four boys in the entire class, and I was the only one who didn’t know Bengali. The next year, we shifted to St. Joseph’s and Mary’s School, and I loved it. I don’t remember anything about it, except that the older boys had their assembly around at 12-1 pm, after we finished our classes, and this one time my principal awarded me a prize for being selected in the IMO. School life had always been good for me, and Kolkata was the beginning of my academic journey.

My sister was born in 2005, and we spent the next year in Kolkata. I’m unsure how I felt about her arrival. I was five and a half. With time, I remember the feeling of having to share my parents with her, which was new and strange, and I was unwilling. A new human being started taking away all my things, which led me to feel annoyed at first. Siblings are territorial, and we were no different. We have some wild stories to tell. I pushed her so hard once that she had to get a stitch on her head. She doesn’t hold that against me anymore, now that I manage to pay her pocket money from time to time.

During this time, our maid used to take care of me. She and her daughter used to babysit me and my sister. She was kind and loving, often shielding me from my mother’s scolding when I refused to study in the evenings, writing down multiplication tables. She even stood up for me when the colony kids bullied me.

That nineteen-year-old evil with a stitched head is now a design student in India, using up all my clothes and my room. She crafts stories and creates art and watches weird shows while eating all the food I used to love. The adulting part of me is now constantly worried about her career, and part of me slightly understands why my parents were constantly fixated on my education and future. It doesn’t justify them, but I see them now. Now that I don’t live with her, I miss her a lot, though I would never admit it to her. I cannot, at any cost, give her the satisfaction of knowing that I miss her.

With my mother having less mobility, I roamed around with my father. Kolkata was a city of yellow taxis, constant honking, and street food. I did not have the same freedom riding my bike as I did in Bhubaneswar, but my father took me everywhere in the metro. Our family and friends visited us regularly, and we often went to the zoo, the Science City, and the Victoria Memorial.

I remember one time I got lost in the Victoria Memorial. My aunt was visiting us, and we went to the Victoria Memorial. I held my father’s hand while gazing at the stars and walking straight. They seemed to follow me as if looking straight at me. I was fascinated by the stars, and I still am. They feel like a nomadic tribe, wandering the sky, telling stories of the past, much like Jajabara. At some point, my father let go of my hand to take out his wallet. Oblivious, I kept walking straight, and when I turned back, I couldn’t see him. I was lost, and an extremely kind family offered me help and asked for my father’s number. They even offered me ice cream, but I was too shaken to eat anything.

Mother never let me go to the Victoria Memorial again. I feel like she had always been my mother in all other worlds—loving, pushing me to get a 100/100 in exams for only God knows what reason, and constantly opposed to whatever I wanted to do because it might be too dangerous, too expensive, or unholy in some way as if God were constantly waiting for me to eat chicken on a Tuesday and punish me for it.

The most memorable part of living in Kolkata would be the train journeys to and from Kolkata to Bhubaneswar. We often visited our home in Bhubaneswar, and I loved the train journeys. The rhythmic sound of the train on the tracks is soothing, and the gentle rocking motion still comforts me while I listen to stories of fellow passengers, living their lives and judging the morality of the world. A time to disconnect from the world and connect with myself, a time to dream, to imagine, and to create.

The train used to halt before entering West Bengal, and my dad would bring food from Kharagpur Station. I feel that the journeys in my life have always been exciting. They helped me live multiple lives, one in Kolkata, and others in the places I visited. During the journey, we halted at various cities, each with different relatives, friends, and stories of their own. Oddly enough, the Indian Railways has a way of making me feel at home.

The transition from Indian Railways to the New York Subway is vivid in my mind, poetic in a way. The boulder, in a different form now, with different stops, 33rd Street, 42nd Street, and 59th Street, as opposed to Balasore, Kharagpur, and Howrah. The train journeys remain the same - a time for introspection.

New York is now my home. Now, I feel like I have always lived here, and the memories of my childhood feel like a distant dream. Turning twenty-five reminds me of the hues of blue I grew up with, the pastel blues of the Indian Railways and the warm blue skies of Bhubaneswar. The blues in New York feel slightly different, colder.

The blue skies remind me of my time in Kolkata, getting lost in the Victoria Memorial, memories of watching Power Rangers, playing too much nintendo, and the tram rides. It reminds me of the food in Kolkata, and the five-year-old me not being able to finish any food. Somewhere in mid-2007, I found myself packed with bags, my mother and cousin’s uncles helping us move with a new boulder this time. This eternal movement in my fate, my Sisyphean journey, was because my father’s job required us to constantly uproot and rebuild in different cities, every two years, as the government mandated it. The following years were spent in Asansol, a small town in West Bengal.

2002-2004. Bhubaneswar, India

May, 2025. Manhattan, NY, US

Next entries:

Life, the Universe, and Everything else

Anubhab Patnaik — Sun, 18 Feb 2024 00:00:00 GMT

This is a recent life update. Amidst the whirlwind of emotions, finding the right words seems like catching lightning in a bottle. I’ve always been the one to share the highs, the adventures, the trips, and the zeal to power through. But now, as I peer into the shadows that have crept into my days, I find myself at a loss. I don’t know where to begin or how to put things into perspective. I might be bad at this, and all I ask of you is to bear with me.

So here’s the deal: This post will be dauntingly long. I’m not promising any grand revelations or profound insights. This isn’t going to be a masterpiece of prose. It’s just me, reaching out to anyone who might need to hear that they’re not alone in their struggles. Because sometimes, just knowing that someone else is stumbling through the darkness alongside you can make all the difference.

December brought forth the wrath of everything life had to offer: the chilly unemployment, the windy solitude, the crushing weight of imposter syndrome, and the cold, relentless struggle with body image and an eating disorder. Lately, I’ve had this epiphany that I’ve been lonely and empty for quite some time now. The reasons remain elusive; I haven’t figured it out yet.

These issues have always been simmering beneath the surface, but starting afresh in adulthood has brought them all to a head—like life suddenly vomited its troubles onto my metaphorical plate all at once. I was fat earlier, but college and friends made it easy. We spent time together, going on road trips and walks, sharing laughs as we strolled through the streets, kicking pebbles, and picking up the nuances of our everyday lives. I never struggled with weight back then.

I weigh roughly the same now, yet adulthood has changed my perspective profoundly. Each step feels heavy as the body weight pulls me down. I’ve stopped buying clothes, knowing ‘L’-sized ones might not fit me anymore. I’ve stopped going out. I find myself avoiding mirrors, dreading the sight of my own reflection and the excess flesh that seems to haunt me. My friends and my oblivious college life made it easy. It never mattered then. It’s a struggle I face daily now, grappling with the physical and emotional toll of my weight.

We pondered how we would pursue our passion and earn a shitload of money, how we would fight, build our future, save for trips, and see the world together. But now, the landscape has shifted. I find myself having nowhere to go and no one to visit. Everyone is consumed by the relentless pace of life. I still talk to those three friends with whom I’ve shared everything for the past two or three years. Nothing changed in friendship. We just grew up. We still hang out with each other. However, the lens through which I view the world has shifted, colored by the stark realities of adulthood. We can’t stay at each other’s homes. We have families to look after, money to save, debts and loans to pay back, deadlines to attend to, and work hard enough to keep our jobs.

On those particularly tough days, I contemplate the meaning of it all—just going through the motions without any real sense of purpose, getting up every morning, trying to get through the day, somehow holding back all that is pulling me down, and going back to sleep, hoping that tomorrow gets magically better.

The cherry on top would be these two most incredible, life-altering things that happened in December: having to find a new job and breaking up.

December enveloped me in its icy grip; its harsh, frigid nights felt especially brutal as I had to leave my job and hunt for a new one. The hunt began several weeks before, but it wasn’t until December that I fully faced the burden of potential unemployment. The situation was perplexing: a tangled web of concerns involving work-life balance, higher expectations from teammates, and wrestling with self-doubt about my future and growth loomed over me. I had to move on.

Each passing day brought a surge of stress and anxiety, accompanied by relentless questions echoing in my mind. Could I make it? Did I truly possess the skills to deserve another opportunity? Or was my past success merely a stroke of luck? The relentless grip of imposter syndrome left me reeling, my eyes weary, and my head pounding with loud thoughts. The fear gnawed at me—what if this were my only chance?

We are the same, you and I, in the same swamps. Trust me, you’ll get there. If I could make it, you would too. I know things are hard right now, and honestly, though I may not have all the answers, I know this much: the path ahead may be daunting, but you’ll make it through. The swamps are dark, but you’re not alone.

The universe dealt its masterstroke when, amidst the uncertain darkness, the one person I could always confide in decided to leave. I shut down. All I wanted was to sleep, avoid confronting the harsh reality, and not get up. But I had to. I was serving my notice period. I had to get up. How else would I pay my EMIs if I didn’t find a job?

My mind raced with a million thoughts. What about the things I planned to do with her? The two-bedroom apartment we were supposed to rent in Bangalore, the road trip to Ladakh we were supposed to go on, and the new car we wanted to save money for—moving abroad together and finding jobs, all dashed in an instant. It felt like a brutal accident. How do I pick myself up and drive to the hospital? How do I go on from here, with no job and no one to talk to?

Life changed after December 15th. I got a job, a better one with better pay, and got the rest of the month off. I tried to put in more work in my relationship, trying to salvage what was left of it. Things started improving. I went back home, spent time with my family, and slept all day. I went back to those familiar streets with that friend, ate all I wanted, unbothered, hung out with my friends, drove past those old streets, rolled down the windows, and let the December ember winds hit me.

I went past those old college roads, looking at tiny ducklings stepping out into the real world. Observing the vibrant energy of youth, oblivious to life’s complexities, untethered, eating and laughing, brought a sense of solace. Brooding over all that I had gone through recently, I remembered that scene from The Dark Knight and realized that the night is darkest just before dawn, and I promise you that dawn is coming.

The universe is oddly funny. January unfolded in vivid, contrasting shades. While work life went smoothly and was promising, my love life plummeted to unforeseen depths. We met, and she bid adieu. It was the end. She was rigid and determined. Her resolve was unyielding as she uttered, “I’ve fallen out of love.”

How does one simply fall out of love? It’s a question that continues to baffle me. Long-distance relationships are inherently challenging, requiring immense love, effort, and dedication to sustain. Any relationship, for that matter, is equally challenging. January left me shattered. I fought hard to get out of this. I tried going on walks and talking to people. Nothing helped.

As a man grappling with both the aftermath of a breakup and the desire for self-improvement, I found myself lost in a sea of uncertainty. A fat guy who got dumped, trying to make it, become thinner, and get payback by building himself up. It didn’t work for me; I couldn’t push myself enough. Life became blank. Those million questions came rushing back. How do you stop talking to somebody you planned your entire life with? This seems like a new life altogether.

She said she needed to explore herself, figure out more about her, and find out who she really was, rather than staying my girlfriend. She said she never got a chance to discover more about herself.

A part of me wanted what was best for her, even if it meant separating. A part of me understood her motivations and truly wished for her happiness, while another part longed for reconciliation, clinging to hope like a fragile icicle. I had no choice but to agree with her, secretly wishing that she would do all this while staying together. A part of me saw through the facade. I knew she had mentally checked out long before. A part of me remembers the last few conversations we had, where she always seemed disengaged, where the conclusion was always the same — she wanted to break up and organise her life. The timeline was just being drawn out. The plans were being charted out.

Had she always been out of love? Or maybe she knew she was going to move on eventually, her exploration of self was always the plan. Maybe a part of her journey was to experience life with different people before finally settling down. Maybe this was all premeditated; letting me down gently over time. A part of me truly wishes the best for her.

The dread begins when you’re still connected on social media and find out that she has moved on. The realization that she had been mentally disconnected long before physically severing ties only added to the anguish. The thought that she moved on a while ago, while you were stuck there, dreaming of a life that was never there, now intensifies this mental agony. The dread is when you ponder all the inconsistencies, like how she claimed she wanted to live life without being involved with men for a year or so before finally moving on, yet it didn’t take her more than a week to let go.

Hope is the most destructive tool. It’s the hope that kills you. Hope builds up when she calls back, wants to talk to you, and tells you she misses you. Hope builds faith. Faith makes you a fanatic. Hope is that same icicle that now wrecks your heart when she says she wants you to move on as she did. What does kill hope?

To you, reading this, if you’re facing similar struggles, know that I’m right there with you, navigating these stormy waters as best I can.

It’s February 18th today. I sit alone in my room, writing this in a familiar place—my chest feeling heavy, lost in the depths of despair, grappling with loneliness, wondering what went wrong and what I could have done differently. Each passing moment feels like a battle, as I wrestle with the question: Where do I go from here?

The idea of stepping into the gym beckons, but doubts claw at the edges of my mind. The thought of lacing up my sneakers and embarking on the daily pilgrimage to the gym fills me with apprehension, each step a painful reminder of my lack of discipline. How do I make friends? Bangalore is a bustling city. My friends do not have time. They are either busy with work, stay far away, or have more important things to deal with. Nobody has time.

I tried dating apps for a month, but they didn’t work. The internet made it pretty clear that the crowd wasn’t interested. Will I be forever alone? In a city teeming with life, I find myself adrift, yearning for connection but unable to find a foothold.

As I said, I don’t have a solution. What has worked for me so far includes:

Hobbies and keeping busy: Life goes on. As you tend to work more, follow up on your hobbies, take up singing classes, pick up those boxing lessons that you’ve always marked as not-done on your list, walk and shop for the shopping list you had, you slowly realize that it isn’t so bad after all. Looking at people from all walks of life, talking to them and living their stories lifts you up.
Reading, watching, gaming: Those half-read books, the shows left behind, and the paused podcasts are yet to be finished. Delving into stories, living lives as mythical new characters, fighting demons in hell, and yearning for the love of your wife like Kratos pushes up your heart. You feel happy, wanting to eat pizza, chug boba tea, and sleep peacefully.
Trips, day outs, and living more: Take out time to live. Do not think; book that solo trip. Order that tandoori chicken and bump up the volume on that stand-up special. Convince friends to build that project together. Take synchronized leaves with friends, and carry out that Goa plan. At the end of the day, you’ll find it easy to fall asleep when you’re tired from the trip, looking at the moon from the beach, and thinking about all that went wrong. You may find a couple of answers written up there, or somewhere beyond the horizon where the water, the sun, and the sky meet.
Talk to people: I know and understand that sharing is hard. But try talking to people—your close friends, family, or even the guy who sells you milk and newspapers. People relate and share stories, and in these conversations, you tend to find answers. Confiding in people helps.

If you’re still reading this, I thank you from the deepest, rockiest bottom of my heart for staying with me and reading through all my misery. If you’re going through something like this, you are not alone. I am still figuring out how to save money, build discipline to go to the gym, lose weight, and find someone—life is too beautiful to spend alone. I’m looking for a group of friends willing to take me in.

I am still inside these swamps, trying just to get a breath and not drown and swirl to the depths. I’ve caught a few breaths, barely staying alive. I can assure you, it gets easier as we move forward. The despair doesn’t recede. We become busy and slowly start moving on. We tend to grow around this space. This is what real growth looks like: waking up someday, not feeling like crying, and actually wanting to look forward to what the day has to offer. Willing enough to go to sleep, peaceful. Starting to live, and not merely exist. We aren’t there yet. We will get there, together.

Decentralization in MetaMUI Wallet

Anubhab Patnaik — Wed, 31 Aug 2022 00:00:00 GMT

I am working with Squbix Digital to build a decentralized, secure and scalable solution using blockchain technology for Sovereign Wallet. The solution is to build a platform to exchange digital assets such as cryptocurrencies and digital currencies across a country/ organization and a cross-border payments system. Here is the metamui whitepaper and here are some of the things that I couldn’t digest well.

Metablockchain-core
A better direction
- Improving the current infrastructure

Metablockchain-core

Metablockchain: The blockchain that lets you regulate digital currencies and cryptocurrencies across the nation. The platform is built on Polkadot protocol that has significantly better runtime efficiency, is cost-effective, and supports parallel faster transactions when compared to other traditional blockchains. The Polkadot protocol is designed to allow unrelated blockchains to securely talk to each other, so that value or data can flow between, say, the Ethereum and Bitcoin blockchains without any intermediary. It’s also designed to be speedy and scalable, via the use of many parallel blockchains (or “parachains”) that take much of the processing demand off of the main blockchain. The Polkadot network can process more than 1,000 transactions per second, compared to about 7 for Bitcoin and 30 for Ethereum. As the network grows and more parachains are added, Polkadot should get even faster, with speeds that could hit a million transactions per second.

Robust, decentralized, and secure?

The product is built in such a way that a country/ government/central banking authority can adopt this platform and make it run parallel with the currently existing infrastructure. Users can send and receive money across the country and it takes significantly less time to handle international transactions. It seems great, an easier way to handle transactions, without having to pay taxes to the government for making international exchanges! But the reality may not be as exciting.

MetaMUI is claimed to solve the blockchain trilemma by having a hybrid architecture. For micropayment, we used centralized architecture to achieve high performance and high security. For higher volume payment, we used decentralized architecture to achieve high security and decentralization.

The current infrastructure is easy to use but is not as secure as claimed. The primary goal of the infrastructure is to make it easier for users to send and receive (traditional banking) money across the country and, it is not secure because it is not decentralized, and well-developed . Introducing a blockchain as a means of a runtime to carry out transactions as opposed to a traditional banking system is to make sure that all the transactions are handled in a decentralized manner and anyone when wanted, can query and view the source, and all the states of the transactions but it is not the case here.

Issues with the current infrastructure

The usage of a private blockchain.

The banks are responsible for running validator nodes that run on the private blockchain and are responsible for validating the transactions and the states of the system. The claims as said were to improve security and transparency but this approach opposes the purpose of the claims. A private blockchain to carry out transactions makes it a kind of database and a runtime that is not public and not accessible to anyone. The banks are servers and the blockchains act as databases. The clients are the users. Seem familiar? This is a client-server architecture with a blockchain running as a database.

Bank Node is a publisher of anonymous tokenized cash. Users can choose Bank Node service providers and have a token contract to issue digital cash. Based on the contract, it can be a debit card or credit card type. When the user pays the merchant with digital cash, the merchant can claim the digital currency to the issuing Bank Node. “The performance of this payment process should be equal to or better than normal credit card payments.”

For high-volume money transfer, MetaMUI utilizes a normal blockchain consensus protocol. All Bank Nodes are involved in the consensus of multiple digital currencies. Since this a transfer between identities, it is a kind of digital cheque payment. Also since we are using blockchain consensus to do so instead of a centralized server for cheque clearance, this is a decentralized cheque system. This payment process is slower than the conventional credit card payment but it is much faster and costs less than an account-based international bank transfer.

Building a platform for carrying out transactions is perfectly okay but introducing blockchains as a means of a just database doesn’t make sense. It feels like a gimmick, a buzzword to secure seed & money from investors. Also, there is nothing wrong with a client-server architecture but the speed of current infrastructure relies on implementing a blockchain as a runtime for transactions, which, as always, is slow. Blockchains are supposed to be secure and transparent but they are not efficient and fast. The transaction data when accessible publicly make the network secure, which it is not, here. Whereas a more traditional client-server architecture is equally secure and more efficient. Look at the current banking and payment gateway scenario in India. UPI payments, net banking, and debit card payments, are all carried out in a secure environment and are blazing fast.

A blockchain-style data store is secure but it is not efficient in terms of computation, communication, and data point of view.

The Consensus mechanism

Consesnus Protocol MetaMUI’s consensus protocol is a combination of PBFT(Practical Byzantine Fault Tolerance) and PoS(Proof of Stake). Only Bank Nodes participate in the consensus of built-in blockchains. Bank Node can be a block proposer and endorser of both built-in blockchains and all digital currency blockchains. The mobile node can participate in the consensus of newly created digital currencies as an endorser. In the case of digital currency consensus, only a Bank Node can be a leader or the block proposer.

Bank nodes have the authority to govern, validate transactions and decide the fate of the entire system, which makes the bank a central authority here. This gives authority to the bank nodes to validate any transactions. The bank may decide to invalidate valid transactions or validate invalid transactions and no one would know cause it would be there “on the blockchain”. (Not saying that this would be done, because a banking sector obviously wouldn’t carry out fraudulent transactions.) This does raise a question about the prorposed solution that claims to have solved the blockchain trilemma.

The leader node also acts as a serializer to serialize transactions. The leader node receives block rewards and transaction fees. Endorser also receives the endorsing rewards when the node’s endorsement is included in the majority vote.

The endorser and leader nodes receive rewards based on the node’s endorsement. The endorser node receives the endorsement rewards when the node’s endorsement is included in the majority vote. The leader node receives the block rewards when the node’s block is included in the majority vote. How does a network with an nPOS consensus protocol pay or reward nodes if there are no gas fees involved?

ACB (Algorithmic central bank)

The current platform runs a single and private blockchain without any overhead of the AI mechanism that will fuel the infrastructure. Implementing the Algorithmic Central Bank can be a key player in the industry. The current platform is inefficient when run using a single private blockchain and no centralized banking establishment to control inflation and deflation. The product can be improved when the existing mechanism as proposed in the whitepaper come to play. The current platform might not be a very good solution for the industry unless the stated propositions come to play.

MetaMUI is just the starting point. We suggested fundamental solutions for Algorithmic Central Bank and a decentralized, but expandable ecosystem based on mobile nodes. But we believe the current development of artificial intelligence technologies such as deep learning and reinforcement learning will be the key game changers of the blockchain platform. MetaMUI was designed to take care of these technologies. In near future, we can see the powerful coordination of more flexibilities based on artificial intelligence and robustness/ stability for transactions based on the blockchain platform.

The digitalization of currency opens up new opportunities for digitalized monetary decision-making. Bank node is an early form of Algorithmic Central Bank that makes monetary decisions based on financial big data. It is possible to apply a federated learning algorithm at the central bank node and collect and learn a decentralized model on many mobile nodes.

Ideological challenges

MetaMUI wallet also lets you regulate digital currencies and crypto-currencies across the world and carry out transactions without having to pay conversion fees. This current implementation of the ideology may become an issue because of the following reasons:

Governments of countries do not generally allow cryptocurrencies to be legal tender. There are two countries as of now that currently allow cryptocurrencies to be traded and accepted as legal tender and both of them are not the most developed or developing nations in the world. Targeting these countries to sell the platform might not be wise.

Governments usually have a means of regulating easier banking methods and exchange methods. Let us take the example of India. India doesn’t allow cryptocurrencies to be legal tender. Digital payments are very popular and online payments being carried out in India follow traditional banking and government norms and are very fast. I don’t think anyone in the current generation nowadays goes to the bank to deposit or withdraw money. Let us take another example of the UID system followed in India, Adhaar system. The system is encrypted using military-grade encryption. The system is very secure and the government is very responsible for the security of the system. The current implementation of encryption used at MetaMUI Wallet is SHA-256 which although a very secure algorithm would seem like legacy software for the Indian government to integrate and work with. The task is tedious and unnecessary.

There seems no solid revolutionary reason for a bank/government to introduce a new platform to run which regulates and carries out transactions and exchanges for free. Excellent existing platforms are already available and our infrastructure is not a new platform. (Paytm, Gpay, Paypal, CoinDCX etc.)

Conversion fees are a means of generating tax for a government. International exchanges or cryptocurrency exchanges are a means of generating tax for a government. When you convert INR to USD or vice versa, you are generating tax for the government. Current conversion from ETH, BTC to INR is a very low fee but there does exist a fee.

MetaMUI Network is an Internet-based cross-border payment network. In MetaMUI Network, each user’s DID is a universal accounting address that user can send or receive digital currencies. Utilizing collateral asset feature and meta-blockchain feature of MetaMUI Blockchain, it is possible to dynamically create meta-coin on the fly to facilitate cross-border payment between the currencies those are not on the MetaMUI Network. Similar to the stable coin issuance, central bank or commercial bank of each country can create stable meta-coin on the MetaMUI Network and perform international fund transfer

The platform introduced doesn’t have gas fees. Gas fees are the fees in a blockchain that you need to pay to make a transaction or carry out a smart contract. A miner validates your transaction by spending its computation power and in return is awarded the gas money. Gas fees are a means of generating revenue for a miner, but having no gas fees in a private blockchain implies that the bank and the infrastructure have to spend money on electricity and computing resources to validate transactions. It doesn’t make sense to have a platform that makes you spend money on electricity and computing resources just to validate transactions.

When users are trading digital stocks or assets in a peer-to-peer way, MetaMUI provides an atomic swap of digital stock and digital currency. Since digital stock is bind to the user’s identity, ownership transfer notification and tax payment can happen at the same time as the stock trade. This eliminates the need for separate shareholder registration, issuance of shareholder certificates, tax reports to the government, and tax payments.

Let us again take the example of India. Cryptocurrencies when made legal in India would have a 30% conversion fee, you’d have to pay a 30% tax to the government for converting the cryptocurrency. It wouldn’t make sense for India to allow the platform to run without a conversion fee. Also, there are a lot of other, well-established platforms playing in the same field and pitching and hitting hard in these areas. (CoinDCX, Coinbase, etc)

Present operating scenario in foreign exchange platforms.

Cheaper, faster, and efficient cross-border payments are the need of the hour in today’s digital world. The MetaMUI Network is designed to host multiple blockchains concurrently. Each of these blockchains can run independently of each other and communicate (transact) with each other. The currency exchange is made possible through atomic swaps and multi-currency transfer is possible with an exchange service provider (Master Node) making it excellent for direct sovereign currency to sovereign currency cross-border payments

The existing exchange platforms are extremely secure, well-established, and highly efficient. The working and operation of these platforms are governed by international laws. The current implementation of MetaMUI Wallet doesn’t include any gas fees for transactions. It’d either have to tie up with an exchange platform or would have to come up with some other way to convince a country to let it handle all of its transactions. Either way, it would be both cost ineffective solutions. With private blockchains and 0 gas fees, MetaMUI Wallet will be having a hard time trying to carry out free transactions across the globe. The organization, at first, would have to pay for the mining and electricity and on top of that would have to pay the cross-border payment fees too.

A better direction

There might exist better, more efficient solutions to the above problems but two of them may have these similar approaches:

Introduce a public blockchain This solves the problem of spending money on validating transactions. Miners can validate transactions and the government/ bank can verify the transactions. This would be a huge bump in security, transparency, and cost efficiency.

It still doesn’t solve the problem of introducing a new platform just to do this. The tax play still becomes an issue here. How does the platform plan on managing taxes? Why would a bank allow a platform to run which would not benefit it in any manner? The government levies taxes to exchange international currencies. Why would it stop doing that? Even if it is allowed, how would it compete with other platforms working towards a similar strategy?

Following traditional client-server architecture using a distributed database This would solve the problem of efficiency. Traditional architectures have been here for a very long time and a lot of research has been done on optimizing the existing infrastructure. Horizontal slicing, vertical slicing, and many other optimization techniques may be used to improve the efficiency of the platform. The platform would be faster, equally secure, and more efficient.

The issue with this approach is that what problem is it really trying to solve. Don’t there exist platforms that are already doing everything this infrastructure is trying to solve? How would it be able to compete with the existing giants? Isn’t the solution building a redundant, regular, exchange banking platform that the world has no less of? How would the platform differentiate itself? What is MVP, the USP of the platform? If it decides to work together with the government, what ensures that other existing strong infrastructures do not also decide to do this and do it better?

Improving the current infrastructure

The approaches may be justified once some of the important issues are addressed. Other than the mentioned problems, a lot of other factors need to make sense in order to improve and make the platform more a feasible good product to be sold. The product being built is excellent, no doubt. The deep learning models in the ACB mechanism, the tech being used, the next generation Polkadot blockchains which are much, much faster (1000 transactions per second as compared to 7-10 transactions in traditional blockchain networks) and allow a huge no. of queries in a much faster time, the faster and more efficient transaction mechanisms, interoperability, the economic scalability, user-driven governance, the forkless upgrades, and the claimed security and transparency, are a step in the right direction, but there are grave issues those still need to be addressed before the product is introduced and launched.

Ref: Whitepaper

Neak: Natural Language --> SQL

Anubhab Patnaik — Sun, 10 Dec 2023 00:00:00 GMT

In the realm of AI, it is evident that for those without technical expertise, the desire to steer away from coding or constructing intricate queries has intensified. The advent of large language models has conditioned us to prioritize results. We do not want to do the manual labor of writing code or queries. Instead, we now tend to present a cluster of questions, offer contextual details, and allow GPT and similar tools to handle the rest. From writing a letter to building scalable applications, LLMs like Chat-GPT, Bard, Llama etc. have become the go-to tools for all our needs. The most complex of tasks, such as writing code or constructing queries have become a breeze.

However, a challenge arises when we seek to safeguard our data from direct interaction with the LLM layer. Neak expands upon the RAG framework by specializing in generating SQL queries from natural language inquiries without letting LLM touch the actual data.

Caveat: This is a work in progress. The code is not yet available for public use. Below is a brief overview of the project.

Prompt Engineering

“Prompt engineering is the process of structuring text that can be interpreted and understood by a generative AI model. A prompt is natural language text describing the task that an AI should perform”. (Source: Wikipedia)

In the realm of AI, SQL query generation utilizes prompt engineering: a prompt, essentially a natural language query, is inputted into the AI model, which in turn generates the SQL query. For accurate query generation, the model necessitates training on an extensive dataset containing questions paired with their respective SQL queries.

Some of the popular models for SQL query generation are:

Lang Chain SQL Generator

Lang Chain has a dedicated module for SQL query generation. The module is called langchain.chat_models.ChatOpenAI. To generate a SQL query from a DB, a short Python code may look like this:

model = ChatOpenAI()

sql_response = (
    RunnablePassthrough.assign(schema=get_schema)
    | prompt
    | model.bind(stop=["\nSQLResult:"])
    | StrOutputParser()
)

sql_response.invoke({"question": "How many employees are there?"})

The function uses the schema of the db to generate an SQL query and then runs the query to get the result. This is part of a code section to generate SQL from plain text. The full code can be found here: Reference

SQL Coder

Defog’s SQLCoder is a state-of-the-art LLM for converting natural language questions to SQL queries. SQLCoder is a 15B parameter model that slightly outperforms GPT-3.5-turbo for natural language to SQL generation tasks on the ‘sql-eval’ framework and significantly outperforms all popular open-source models. It also significantly outperforms text-davinci-003, a model that’s more than 10 times its size.

SQLCoder is fine-tuned on a base StarCoder model. Defog was trained on more than 20,000 human-curated questions. These questions were based on 10 different schemas. None of the schemas in the training data were included in the evaluation framework. Reference

Picture this: you need SQL queries for your database’s data. Usually, an AI or LLM needs the dataset or context to generate these queries. But here’s the catch – sharing sensitive data with the AI layer might not be safe. The data might be leaked, and the privacy of the users might be compromised. You would not want to share your data with the AI layer.

RAG pipelines

A recent addition to the NLP landscape is the RAG (Retrieval Augmented Generation) pipeline. This involves retrieving relevant documents from a large corpus and then using a generator to generate the answer. Retrieval-Augmented Generation (RAG) is the concept to provide LLMs with additional information from an external knowledge source. This allows them to generate more accurate and contextual answers while reducing hallucinations.

Advantages of RAG pipelines:

The retriever only provides the relevant data to the generator. This

reduces the amount of data that the generator has to process,
improves the accuracy of the generator as it hallucinates less, and
protects the privacy of the data.

Some of the recent RAG pipelines are:

Lang Chain

Lang chain also implements dedicated workflows using RAG pipelines. The data is stored in a vectorstore and the retriever is a FAISS index. The generator is a LLM. A code snippet to generate SQL from plain text using RAG pipelines looks like this:

vector store = FAISS.from_texts(
    ["Harrison worked at Kensho"], embedding=OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever()

template = " Answer the question based only on the following context:
{context}

Question: {question}
"""
prompt = ChatPromptTemplate.from_template(template)

model = ChatOpenAI()

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | model
    | StrOutputParser()
)

chain.invoke("where did harrison work?")

The code attempts to create a vector of data and then uses the vector to retrieve the answer. The generator breaks down the question into words and then generates a vector for each word. The dataset is then searched for the nearest vectors and only the relevant data is sent to the AI model/ LLM to generate the SQL query.

The full code can be found here: Reference

Llama Index

Llama Index follows a similar RAG pipeline. In Llama Index, a query engine is a generic interface that allows you to ask questions about your data.

A query engine takes in a natural language query and returns a rich response. It is most often (but not always) built on one or many indexes via retrievers. You can compose multiple query engines to achieve more advanced capability.

# paul_graham_essay.txt
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query("Who is Paul Graham.")

To stream response:

query_engine = index.as_query_engine(streaming=True)
streaming_response = query_engine.query("Who is Paul Graham.")
streaming_response.print_response_stream()

Here, the essay is vectorized, and then the query engine is used to generate the answer. The full code can be found here: Reference.

An RAG (Retriever-Generator) pipeline comprises two core components: a retriever and a generator. In this setup, the retriever functions as a vector store, while the generator is typically an AI model, often an LLM. Their collaboration involves the retriever’s task of extracting pertinent data from the vector store based on the question, followed by the generator’s role in crafting the answer.

Thus, you would want to use an RAG pipeline to generate the SQL queries instead of sharing sensitive data with the LLM layer. However, RAG pipelines tend to be slow and are not as accurate as prompt engineering. The process of storing the data in a vector store and then retrieving the data from the vector store is time-consuming. After that, LLMs tend to hallucinate a lot.

Neak

Neak builds up on the LlamaIndex query engine and tries to solve this performance issue. It tries to reduce the time taken to generate SQL queries using RAG pipelines and reduce the hallucinations.

Neak achieves this by:

Improving the retriever
- Chunking only the schema of the database and not the actual data.
- Setting the chunk size efficiently. A single chunk corresponds to a single table in the database. The chunk size is small enough to not leak any sensitive information.
- Using an in-memory vector store to store the schema.
Improving the generator
- Using a sub-querying engine to generate better prompts from the original query/ question.

Chunking

Using Llama Index’s chunking engine, the schema of the database is chunked. The chunk size is set to a single table. This ensures that no sensitive data is leaked.

The chunks of the Postgres database may look something like this:

{
    "public": {
        "departments": [
            // chunk 1 in raw text
            {
                "columnName": "department_id",
                "dataType": "integer",
                "isNullable": "NO",
                "default": "nextval('departments_department_id_seq'::regclass)",
                "udtName": "int4",
                "udtSchema": "pg_catalog"
            },
            // chunk 2 in raw text
            {
                "columnName": "department_name",
                "dataType": "character varying",
                "isNullable": "NO",
                "default": null,
                "udtName": "varchar",
                "udtSchema": "pg_catalog"
            }
        ],
        "employees": [
            {
                "columnName": "employee_id",
                "dataType": "integer",
                "isNullable": "NO",
                "default": "nextval('employees_employee_id_seq'::regclass)",
                "udtName": "int4",
                "udtSchema": "pg_catalog"
            },
....

The data is chunked only while initializing the engine. Once the chunking process is complete, the chunks are stored in an in-memory vector store. The vector store is then used to retrieve the data.

Prompt Engineering

The generator converts the query into sub-queries, answers each query asynchronously and then combines the results to generate the final SQL query.

A question like “How many active employees are there with age more than 45 and working in the education sector, and are eligible for a bonus?” is converted into sub-queries like:
“how many active employees are there with age more than 45?”
“how many active employees are there working in the education sector?”
“how many active employees are there eligible for a bonus?”

The sub queries are then answered asynchronously and the results are combined to generate the final SQL query.

What’s next?

RAG pipelines are not perfect. Neak is a fine model, but not ready for production yet. It is in a nascent stage and requires a lot of refinement. Some of the issues that I faced are:

GPT-3.5 turbo and GPT-4 hallucinated a lot. The results were not accurate.
The time taken to retrieve the chunks has reduced, but the query generation is still slow. Although the sub-queries are generated asynchronously, the time taken to generate the final query is still high. The overall difference in time taken to generate the query is not significant.
there is no context stored. A chat-based approach may be better.

While better alternatives like Defog’s SQLcoder, which operates locally using Huggingface’s transformers, resolve data leakage concerns, their complex setup poses usability. For an average person, setting up an AI model to run locally is not easy.

Technically, the most apt way to generate SQL queries is using RAG pipelines with fine-tuned models. While this is a more challenging approach, it is also the most accurate and secure. Neak is merely a bleak attempt to solve this. It is a work in progress and requires a lot of refinement. in the future, I plan to follow an approach similar to Defog’s SQL coder: fine-tuning open-source LLMs and then using them to generate SQL queries using the Llama Index based Neak’s approeach: a sub-querying engine.

The Parakeet King

Anubhab Patnaik — Thu, 01 Aug 2024 00:00:00 GMT

I recently wrote about battling anxiety and depression. After six months, writing about something uncomfortable seems partly easier now. My last article helped me engage with an audience experiencing similar struggles. It’s remarkable how much we can uncover about each other’s inner worlds simply by communicating. Everyday conversations can be incredibly therapeutic—a reminder that we are not alone in our struggles, and my recent experiences have been a testament to this.

The last article shed light on how my life transitioned from one horrid experience to another, how life kept pushing and pushing, each time scraping a larger piece of my knees. In a journey fraught with self-doubt, anxiety, and depression, I found myself grappling with all kinds of challenges life threw my way. Moving from one trouble to the next, I built up ounces of resilience as I walked through these challenges, slowly attempting to fight back and stand up again. While trying to regain my footing, I grasped a few outstretched hands reaching toward me, taking slow steps, hesitant with the looming possibility of failure. As I began to walk again, I realized I wasn’t alone. Others walked alongside—some ahead, some behind—each with their own stories and struggles.

Now, looking around, I see familiar faces looking back at me. Some walk along the same path as me. While, some are ahead. They acknowledge their missteps, their gaze carrying the weight of a million untold stories—apologetic yet determined to make amends. We walk together, hoping to help each other move forward. Some just want to talk, wanting me to be there and listen and not judge. To be there for them. That’s all it takes. Others, too tired to take the next step, want to change lanes and ask for help.

As we walk alongside each other, this eerie feeling of “this happened to me too” surrounds us. I realized that our lives were not very different from each other. All of us walking together are equally in debt, though with separate issues, but we are there together. Talking and sharing with each other helped me scratch the surface of the walls, looking behind them, uncovering the unsettling darkness. These are the walls we construct in our lives and not look behind. The walls that we build to protect ourselves from the world.

In a world teeming with activity, it’s apparent that everyone, everywhere, is grappling with their own set of challenges. Life has universally become a struggle. Some speak about the dysfunctional job market, some about house prices soaring through the roofs of lighthouses, some about increasingly stressful finances, and others about how capitalism has reached its peak: the rich get richer.

Amidst the bustling cityscape, forging genuine connections feels like an insurmountable feat. The ones you want to talk to are in a different city, timezone, or space altogether. They are not available anymore. Those promises we made while leaving school and college—promises to stay in touch, meet, and gossip—were all mere promises: sweet and generous lies we told ourselves. We moved on and learned to live without each other. The family has done its part. Exploring what you are passionate about while managing unwilling expenditures in a delusional “life” within the work-life balance is eating you up from the inside, and our mere existence feels morbid. We grapple with our internal demons, navigating the labyrinth of our minds where uncertainty rules. The inevitable challenge now becomes wrestling with the monsters that inhabit your gray space. Welcome to the daunting realm of adulthood!

Amid this darkness, empathy proved to be a beacon of light. With a myriad of challenges weighing me down—financial issues, work-life balance struggles, having to find new work, living alone, grappling with weight gain, being unable to make friends, experiencing a breakup, and what else not-the empathy I received was my knight in shining armor.

I turned twenty-four last month. Life has been gradually improving for quite some time now, ushering in a subtle calmness with each day. The days are still a blur of monotonous routines, the nights a cycle of napping with nothing to do, but I find myself more at peace with the world. Each morning, I awaken with a sense of purpose, eagerly planning my day and contemplating the possibilities lying ahead. I’ve settled into a new workplace, made new friends, and realized that the trials I faced were not mine alone. Through heartfelt conversations, I discovered that others were navigating similar storms.

I asked my friends to read my article about the issues I had been experiencing. They loved it and shared feedback. They rooted for me as if I were the main character. They wanted to help. They shared their stories and showed me different perspectives. I realized the world works differently for each individual. Speaking to them helped me understand that it is okay and that these struggles are common. One colleague confided in me about experiencing impostor syndrome, a sentiment I wrestled with. She said she also thinks she somehow got this job by chance. Another friend shared that he went through a similar breakup process. It’s uplifting to see connections with friends and colleagues becoming meaningful experiences.

One friend mentioned he had been looking to join a gym for a long time, while another wanted a badminton buddy, just like me. Some wanted to go on trips, and others wanted to hang out after work, have a beer and talk about everyday life. A friend from my previous company reached out for help, saying it had become too much for him, and he needed an escape. Grappling with job switching and confiding his issues in me helped him discover new insights. Some of my juniors reached out for help, and we started working together on projects to improve our collective knowledge. Talking to people, sharing my problems, listening to theirs, collectively trying to come up with solutions, and being involved in others’ lives brought a sense of fulfillment.

There are still many things on my list. Now, I find it easier to tick them off one by one. I resumed playing the guitar. I planned and went on new trips with my family, tried out river rafting with my mom and sister, and visited deserts, mountains, and beaches. I resumed my coding community, made new friends, and got busy. I learned that I am not the only one unsatisfied with their cook. I am not the only one looking for a better apartment. We chat about our short stories, lives, and places we come from. Talking about these countless things started lifting me up. I didn’t plan on doing that. It just happened.

I now find joy in simple pleasures: having a hearty breakfast, coaxing colleagues into joining me for fancy lunches, and persuading friends to hang out and spend an evening of fun before settling into bed, weary but fulfilled. An evening stroll, working from a café, catching the latest movies with friends and colleagues, attending stand-up comedy shows, and trying out new beer breweries, gin joints, and pubs before bed have become my daily norm. We spend most of our lunches outside. Time passes by, and we don’t even notice. Amidst it all, I find solace in the conversations and connections made along the way. Together, we navigate life’s ups and downs, finding support in each other’s company.

These conversations transcend the mundane, offering glimpses into each other’s lives, dreams, and struggles. As we share our stories, I find solace in the fact that my experiences are not unique. We laugh, commiserate, and dream, finding comfort in our shared humanity. Visualizing lives from another perspective helps us remarkably. Empathy reigns, and we look forward to living another day more resilient, breaking bread, and gulping beer with each other as we engage in laughter and mutual connection.

We are all stuck here. You might be on the further end of the scale than I am right now. But both of us are here. If I could walk downstairs, you can too. Talk to people, share, watch movies, read stories, get lost in a million other worlds, and address your issues. In the end, it all becomes an act of letting go. It took me some time to figure this out: you take the sourest lemon life has to offer and turn it into something resembling lemonade. Share it with others; live, try, and help others live. Build memories. After all, that’s all we are, really. Memories.

- the evildoer
undersigned

QTree - Images in Quadtrees

Anubhab Patnaik — Tue, 14 Feb 2023 00:00:00 GMT

I stumbled upon KoalasToTheMax while reading a blog post about the most exciting web pages built for fun, and I was blown away. Srijan explained how it works, and we were inspired to create something similar.

But first, let’s get into the basics of the data structures used in our project.

Quadtree
- Member Functions
- Node
Demonstration
Setting up the Canvas

Quadtree

A quadtree is a tree-based data structure where each node has exactly four child nodes. Our quadtree represents a partition of space in two dimensions by dividing the region into four equal quadrants. Each quadrant is then subdivided into four equal quadrants, and so on. Each node in the tree has exactly four children or no children at all, which makes it a leaf node. The height of a quadtree depends on the amount of data being decomposed.

The root node is the image. Each node is the average value of its children’s pixel values. The tree is recursively subdivided until each leaf node is a single pixel. The tree is then traversed to compress the image. To decompress the image, the tree is traversed again.

Member Functions

Our quadtree has the following member functions:

compressImageData : It takes the image data and the compression factor as the input and returns the quadtree.
createQTreeOfHeight : It takes the height of the tree and the bounding box as the input and returns the quadtree.
populate : It populates the quadtree with the pixel values.
getRGBValuesFromCoordinates : It takes the quadtree and the coordinates as the input and returns the pixel value at the given coordinates.

Node

The QTNODE class represents a node in the quadtree. It has the following properties:

x : x-coordinate
y : y-coordinate
w : width of the bounding box.
h : height of the bounding box.
children : array of four children.
rgb : pixel value of the node.

Functions:

draw : draws the node. Takes the canvas context as the input and returns nothing.
insert: inserts a node into the quadtree. Takes the quadtree and the node as the input and returns the quadtree.
drawAtHeight: draws the nodes at a given height. Takes the canvas context, the height of the tree, and the current height as the input and returns nothing.
draw: draws the nodes. Takes the canvas context and the height of the tree as the input and returns nothing.
reveal: reveals the nodes. Takes the canvas context and the height of the tree as the input and returns nothing.
computeAverageColor: computes the average color of the node. Takes the quadtree and the image data as the input and returns the pixel value.

Demonstration

Hover over any part of the canvas to recursively divide it into four quadrants.

The slider controls the depth of the tree.

The slider is set to 0 by default, which means the entire image is compressed into a single pixel. The slider when set to 100 means the image is not compressed at all. The slider can be set to any value between 0 and 100.

Setting up the Canvas

To start with, we need two canvases - one for you to hover over and the other for you to control the depth of the tree using a slider and render the nodes evenly. Initially, we had multiple ways of taking an image as the input form, such as uploading an image, using query parameters, etc. But for this demonstration, we’ll keep it simple and use a static image.

Here’s some JavaScript code that will load the image into a canvas:

const image = new Image();
img.src = "/blog/assets/images/qtree/cryptopunk.jpeg";
img.onload = () => {
    initSliderCanvas(img);
    initMouseCanvas(img);
};

I’ll go ahead and explain the working of the mouse hover canvas and you can explore the slider canvas. The code is available on GitHub, and you can play around with it later if you are interested.

import { compressImageData } from "./qdtree.js";
function initMouseCanvas(img){
	const canvas = document.getElementById("canvas-2");
    const ctx = canvas.getContext("2d");

    const imageData = readImageDataUsingCanvas(canvas, ctx, image);
    const qTree = compressImageData(imageData, 1);
    qTree.draw(ctx);
	...
}

Image Data Compression

Now, let’s get to the fun part - compressing images. We import the compressImageData function from the qdtree.js file. This function takes the image data and the compression factor as the input and returns the quadtree. The height of the tree is calculated by taking the log of the number of pixels in the image and dividing it by the log of 4 (number of children of a node). The log of 4 is 2, and the log of the number of pixels is the height of the tree. The height of the tree is then rounded down to the nearest integer. The tree is then created using the createQTreeOfHeight function that takes the height of the tree and the bounding box as the input and returns the quadtree.

qdtree.js

export function compressImageData(imageData, factor) {
  const { width, height } = imageData;
  const newWidth = Math.ceil(width / factor);
  const newHeight = Math.ceil(height / factor);

  const qTreeHeight = Math.floor(Math.log(newWidth * newHeight) / Math.log(4));

  const qTree = createQTreeOfHeight(qTreeHeight, {
    x: 0,
    y: 0,
    w: width,
    h: height,
  });

  populate(qTree, imageData);
  return qTree;
}

The createQTreeOfHeight function takes in the height of the tree and the bounding box as the input and returns the quadtree.

Bounding Box

The bounding box is the area that the node represents. The bounding box is initially the entire image. The bounding box is then divided into four equal quadrants, and the process is repeated until the height of the tree is 0. The populate function takes the quadtree and the image data as the input and populates the tree with the average pixel values of the children’s pixel values.

 function createQTreeOfHeight(height, aabb) {
  function recursiveCreate(node, height) {
    if (height === 0) return;

    const { x, y, w, h } = node.aabb;
    const halfW = w / 2;
    const halfH = h / 2;


	//top left
    node.tl = new QTNode({
      x,
      y,
      w: halfW,
      h: halfH,
    });
		//top right
    node.tr = new QTNode({
      x: x + halfW,
      y,
      w: halfW,
      h: halfH,
    });
		//bottom left
    node.bl = new QTNode({
      x,
      y: y + halfH,
      w: halfW,
      h: halfH,
    });
		//bottom right
    node.br = new QTNode({
      x: x + halfW,
      y: y + halfH,
      w: halfW,
      h: halfH,
    });

    recursiveCreate(node.tl, height - 1);
    recursiveCreate(node.tr, height - 1);
    recursiveCreate(node.bl, height - 1);
    recursiveCreate(node.br, height - 1);
  }
 }

Image data to Quadtree

Alright, let’s talk about the reveal function, which is like a magician revealing the hidden nodes under the mouse. And then there’s the draw function, which is like an artist sketching the nodes on the canvas. The update function is like your mom constantly cleaning up after you every 30 milliseconds. It clears the canvas and redraws the nodes on the canvas, all to make sure it looks neat and tidy.

function initMouseCanvas(img){
	...
 const mousePos = { x: 0, y: 0 };
    let lastUpdateTime = -Infinity;
    const frameTime = 30;

    function update() {
        const currentTime = Date.now();
        const diff = currentTime - lastUpdateTime;
        if (diff < frameTime) return;

        lastUpdateTime = currentTime;
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        qTree.reveal(mousePos.x, mousePos.y);
        qTree.draw(ctx);
    }

    canvas.addEventListener("mousemove", (e) => {
        const rect = canvas.getBoundingClientRect();
        const x = e.clientX - rect.left;
        const y = e.clientY - rect.top;
        mousePos.x = x;
        mousePos.y = y;
        update();
    });
}

Conclusion

So, what’s the point of all this? Well, we can use a quadtree to compress and decompress images when the mouse hovers over a specific area of the canvas. It’s like a secret code that unlocks a hidden image!

Ref: Wikipedia

Resoc, a gift to my alma mater

Anubhab Patnaik — Fri, 17 Mar 2023 00:00:00 GMT

RESOC, a free and open-source platform that primarily lets you share notes, question papers, and other academic resources with your friends and classmates.

How it all started

The idea came to me in the first year of my undergrad, when I found myself scouring the internet for notes, and calling up friends in the middle of the night. I have a terrible habit of studying just before the exam( and I am sure, you do too ), and at the end of the day, I always find myself having nothing to read from. This led me to build a Google Drive collection that became an instant hit among my peers. Everybody wanted the link! I didn’t bother to put much effort into it, and it was just a bunch of notes that I had collected over the years. Later, I built a static html page and hosted it on GitHub pages.

Cut to the end of 2022, in my final year, I decided to join together bits and pieces from other projects to build RESOC. Resoc is a community-driven platform that lets you share notes, question papers, and other academic resources with friends and classmates. It also helps you stay organized with a personal task board, and a community chat page to interact with other users. The platform is built using React and Firebase and is hosted in Firebase Hosting. The notes are stored in Google Drive, and the user data is stored in Cloud Firestore. The platform is open-source and can be found here.

The open-source codebase

Going forward, I would want to make the platform more user-friendly and add more features. It has bugs and lacks a lot of implementations for the features we have added. Since it is primarily made for my alma mater, I would want a silicon student to pick this up, fix the issues, and maintain it. To get started, here’s a brief overview of the codebase:

Frontend:
- React
- React Router
- Bootstrap
- Undraw + Storyset for illustrations
- React - Firebase for Firebase integration
- Context API for state management
Backend:
- Firebase
- Google Drive for storing and fetching notes
- Firebase Authentication for user authentication: Google OAuth and email/password are used for authentication using Firebase Authentication.
Database:
The notes are in Google Drive, and Cloud Firestore is used for authentication and storing user data, tasks, and chat messages. Firebase storage is used to store files uploaded by users and contributions.
Hosting:
- Firebase Hosting for hosting the platform.
- A GitHub action is used to deploy the codebase to Firebase Hosting.

Features

The primary features of RESOC are sharing Notes, Question Papers, and other academic resources. Other than this, users can have a personal Kanan board to manage their tasks. The community chat page is a place where users can interact with each other. Resoc also includes community contributions, where users can contribute to the platform. The platform also includes a team page, where the team members are listed, and there are specific community guidelines that need to be followed.

Deep Dive into the codebase

The major components and routes are:

/team - The team page
/notes - Collection of notes arranged by year and branch. The structure is terribly simple. The IDs are hardcoded and the notes are stored in a JSON file.
/previewnotes - The page that renders the notes. The notes are stored in a JSON file and the links are hardcoded.
/community-guidelines - The community guidelines page, lists a couple of rules on public contributions of notes, and the chat.
/community - The community chat page is built using Firebase Firestore. The chat is real-time and uses WebSockets under the hood.
/taskboard - The task board page has the bare minimum features.
/login - The login page, uses Google OAuth for authentication; the user needs to login to access the chat and task board.
/signup - Basic signup page
/forgot-password - Basic forgot password page
/contributions - The contributions page, where users can contribute to the platform. The contributions are stored in Firebase Storage.

Getting Started

The best way to get started would be to clone the repository and try running and exploring all sections of the web app to become familiar with the codebase. The codebase is open-source and can be found here. The codebase is a Nodejs project, so you would need to have Nodejs installed on your system. You can install the dependencies by running npm install in the root directory. You can run the project by running npm start.

The React codebase is in the src folder. The components folder contains all the components used in the project. The context folder contains the context APIs used in the project. The root folder contains the Firebase configuration.

The control starts with the index.js file that renders the App component. It contains the routes and the context providers. The App component is the home page. contexts/authContext.js contains the context API for authentication. Components are lazy-loaded using React Lazy, and the routes are protected using the PrivateRoute component.

Each page is a separate file in the components folder. The utils folder contains the utility functions used in the project.

Notes

The notes are rendered from a metadata file: data.JSON, that contains two types of elements in the list. One specifies the header: the year or the branch, and the other is the actual notes. The notes component renders a list of links using this data. Each link is a button that opens the new preview_notes component. The reason behind using a JSON file is to make it easier for the maintainers to add notes, and to enable a search feature using the tags. This isn’t a traditional search feature, but a filter feature that filters the notes based on the tags. It was a simple solution, so I didn’t bother to put much effort and used a simple filter function.

Community Chat

The community chat is built using Firebase Firestore. The chat is real-time and uses WebSockets under the hood. The chat is stored in the chats collection in Firestore. It includes a button to load more messages and sign out. The ChatRoom component, memoized for performance, fetches and displays messages from Firestore, and allows users to send new messages. The ChatMessage component, also memoized, formats and displays individual messages, including handling URLs within the message text.

Task Board

The task management interface integrates with Firebase Firestore to store and manage tasks. The tasks are fetched from Firestore and displayed in a list, with options to mark tasks as done or delete them. It includes form elements for adding new tasks and buttons for marking tasks as done or deleting them.

Contributions

Contributions, allows users to upload files to a Firebase storage and submit their contributions. It includes form elements for displaying the user’s name and email and input for file selection. It handles file uploads, displays upload progress and shows success or error messages based on the upload status. It also provides a download link for the uploaded file and instructions for further actions. It uses Firebase for authentication, Firestore for storing metadata, and Firebase Storage for file uploads.

Here’s why there was a need for authentication:

There are various actions that would need to distinguish individual users. From uploading notes to maintaining personal task list and communicating with the community, authentication is a must. RESOC uses Google OAuth for authentication. The login/ signup page handles basic authentication using Firebase Authentication. The email verification is deliberately not implemented. We don’t users to feel violated by the platform. The signup page is a simple form that takes the user’s email and password and creates a new user account using Firebase Authentication. The login page is a simple form that takes the user’s email and password, and signs in the user using Firebase Authentication. The forgot password page is a simple form that takes the user’s email and sends a password reset email using Firebase Authentication.

Other features include a team page, community guidelines, and a login page. The team page lists the team members and their roles and includes links to their profiles. The community guidelines page lists a couple of rules on public contributions of notes and the chat. The login page uses Google OAuth for authentication; user needs to login to access the chat and task board.

Next?

There are a ton of features and fixes we are looking to implement in the platform. A couple of bugs that we are looking to fix are:

The structure of the notes page is terrible. We want to refactor the notes page to make it more readable and uniform. It needs to handle dynamic updates to the notes like adding a subject in the middle of the list. Right now, the IDs are serialized and hardcoded.
The community chat loading page is too slow; we want to store the chats in cache before lazy loading them to make the page load faster.
The contributions page needs to have a github service trigger that would automatically create a pull request to the repository with the new contributions. It also needs to be able to handle new subject additions.
The router fails when a page needs authentication and the user is not logged in. When the user logs in, he should be redirected to the page he was trying to access, not the default profile page.

Metrics

RESOC Traffic during exam time!

RESOC Traffic in 2024!

Rust: the future C++?

Anubhab Patnaik — Fri, 14 Oct 2022 00:00:00 GMT

While choosing the next language to learn, or to use for building a high-performing, memory-efficient application, you might have come across Rust. Here’s a breakdown of what I found about Rust and how it compares to the already existing compiled language king, C++.

Rust is a multi-paradigm systems programming language created to ensure high performance similar to that offered by C and C++, but with emphasis on code safety, the lack of which is probably why C and C++ are painful to deal with. It accomplishes memory safety without using a dedicated garbage collector. Rust is also an ahead-of-time compiled language, which means that you can compile a rust program, give it to someone else, and they can run it even without having Rust installed. However, Rust has more than just memory safety on its side. High performance while processing large amounts of data, support for concurrent programming, and an effective compiler are other reasons why well-known software heavyweights such as Firefox, Dropbox, Cloudflare, and many web-3 startups and large corporations use Rust in production.

Some questions that may come to your mind are:

If Rust is created to achieve performance similar to that offered by C++, then why not use C++ instead?
I know Java, JavaScript, and Python to be more popular choices amongst peers. Why not use those languages instead?
What about new languages like Go, Kotlin, Swift, etc.?

To answer these questions, let us first go through how a programming language works.

Programming Languages and their working
- Compilers and interpreters
- Compiled Vs Interpreted languages
C++: The king of programming languages
Memory management in programming languages
- c++
- Garbage collection
Rust
- Rust > C++

Programming Languages and their working

A programming language is a set of instructions that can be used to interact with and control a computer. These languages can be used for a multitude of purposes, such as creating a website, analyzing data, writing a program to solve a mathematical problem, creating a game, piloting a car, building a robot, making rockets take off, controlling spacecraft and the list goes on. A computer, even though can control a rover on Mars, detect an incoming ballistic missile, and detonate it before it reaches you, cannot understand English, or anything else except ‘0’ & ‘1’. Computers can be thought of to be made up of tiny switches, and can be either ‘on’ (1) or ‘off’ (0) called ‘bits’. Whatever instruction you want to execute on a computer, has to be converted into a series of '0’s and '1’s before it can be executed. Even a simple “Hi” is parsed as 01001000 01101001. Yes, this is what Siri responds when you Hey Siri. Since the English language is vast and complicated, it is not possible to convert it into a series of ‘0’ and ‘1’ directly. A subset of English or any other language is created, which is called a programming language. High-Level Programming Languages have English-like syntax and are designed to be easy to read and write, whereas low-Level Programming Languages are designed to be easy for the computer to understand. To make things easier for us, there are tools that convert whatever we want the computer to do into a series of '0’s and '1’s. This series of '0’s and '1’s is then executed by the computer.

Compilers and interpreters

A compiler or an interpreter is a tool that converts a program written in a programming language (source code) into a series of '0’s and '1’s that can be executed by a computer. Compilers and interpreters differ in the way they work. A compiler converts the entire program into a series of '0’s and '1’s (machine code) and then executes it. An interpreter, on the other hand, executes the program line by line.

Why did we need interpreters?

Compiled languages need a “build” step. You need to compile your program before you can run it. To run your program on a different computer, you will have to compile it on that computer as well. Interpreters run through a program line by line and execute each command. You can run a program without having to compile it first. This makes it easier to run programs on different computers.

Another notable disadvantage of compilers is platform dependency of the generated binary code. Compilers are designed to be CPU specific and run on a specific CPU architecture. This means that if you want to run a program on a different CPU architecture, you will have to compile it again.

Why do we still make use of compilers ?

Compilers are designed to be CPU specific, and as a result, they tend to be a lot faster and more efficient than interpreters. They also give the developer more control over hardware aspects, like memory management and CPU usage.

A compiler is faster and more efficient than an interpreter, but an interpreter is easier to write than a compiler.

Compiled Vs Interpreted languages

Interpreted languages were once significantly slower than compiled languages. But, with the development of just-in-time compilation, that gap is shrinking. Modern scripting languages like Python and JavaScript are compiled to machine code at runtime using both compilers and interpreters, which makes them as fast as compiled languages. They are first compiled into an intermediate representation called bytecode, and then interpreted by a virtual machine which converts it to machine code.

If you’re wondering what language should you choose to build your next project with, ask yourself this: what kind of platform do I want the application to run in? If you want to run your application on a web browser, you should go with JavaScript or TypeScript. If you want to run your application on a server, you may want to use Python or Go. In a mobile device, Swift or Kotlin might be the way to go. C++ is used for building complex applications and systems software, such as operating systems, browsers, and video games which require a heavy performance overhead.

Rust, Go and C++ are popular compiled languages that are used for building high-performance applications. Python and JavaScript are popular interpreted languages that are used for building web applications.

The speed advantage of the compiled language such as Golang (Go) in comparison to an interpreted language such as Java is one of the reasons why organizations write their microservices in Go. In complex computing environments such as cloud computing environments, where users get charged for every clock cycle, it makes sense to use the most efficient deployment artifact.

C++: The king of programming languages

C++ is a low-level, statically typed object-oriented language that allows you to have a good grasp of your computer’s resources and utilize them at your convenience. Since it is a compiled language, it surpasses the performance of most of the other interpreted languages. It is an extremely powerful language and is used in many applications such as operating systems, video games, the development of compilers and interpreters, etc. It has a huge community and is one of the most popular languages in the world.

Reasons why C++'s performance is unparalleled:

A compiled language. C++ is extremely fast because it is a compiled language.
A low-level language. It allows you to cheaply use computing resources.
Statically typed. It allows the compiler to optimize the code.
Object-oriented programming. It allows you to create reusable code.
A general purpose language. It can be used to create any kind of application.

The issue with C++ boils down to how it manages memory. C++ is prone to memory leaks and dangling pointers, if not written properly.

Memory Management in programming languages

Variables are named memory locations that store data. A variable is a container that holds a value. The value can be of any type, such as integer, float, character, etc. Example:

int a = 10;
float b = 10.5;
char c = 'a';

Computer programs need to allocate memory to store variables, data values, and data structures and deallocate memory when done using them. Memory is also used to store the program itself and the run-time system needed to support it. Programming languages can be categorized as those which provide automatic memory management and those which ask the programmer to allocate and free memory manually. Requiring the programmer to manage memory manually leads to a simpler compiler and run-time but requires more work from the programmer and is more error-prone. While automatic memory management is more convenient for the programmer, it is also more complex and slower and it is achieved by the use of garbage collection.

C++

C++ is a low-level language with manual memory management. C++ programs manually allocate and free memory using pointers.

Pointers Pointers are variables that store the address of another variable and access the memory location of a variable. Pointers are used to pass large data structures to functions, to return multiple values from a function, to dynamically allocate memory, etc. Since there is no automatic memory management in C++, you need to be responsible for allocating and freeing memory. This process is achieved using the malloc, calloc, new, and delete keywords.

With manual memory management, a few things can go wrong like memory leaks and dangling pointers. For instance, the dangling pointer problem arises when there is an attempt to use a pointer after it has been freed. Dangling pointer errors can arise whenever there is an error in the control flow logic of a program. The use of a pointer before allocation may be a fatal run-time error. Use after deallocation is not always fatal but neither of these is a good thing.


#include <stdio.h>
  int main()  
  {
    int *ptr=(int *)malloc(sizeof(int));  
    int a=560;  
    ptr=&a;  
    free(ptr);  
    // dangling pointer
    printf("%d",*ptr);
    return 0;  
}

The above code will produce a segmentation fault since the pointer is pointing to a memory location that has been freed. To avoid this, we can set the pointer to NULL after freeing it.


    free(ptr);
    ptr=NULL;

Memory leaks and dangling pointer bugs are some reasons why C++ is not preferred for applications that require a lot of memory management. To avoid such issues, languages that provide automatic memory management are preferred over C++. Scripting languages manage memory using a garbage collector.

Garbage collection

Garbage is a memory that was once used by objects but will never be read or written by the program again. A garbage collector (GC) is a background process that provides automatic memory management for modern languages by taking care of the allocation and deallocation of a program’s computer memory resources. As a result, certain categories of bugs are eliminated or substantially reduced such as:-

Dangling pointer bugs - a piece of memory is freed, but the objects still have references – one of these references is used in the program.

Double-free bugs – the program attempts to free a piece of memory that has already been freed.

Memory leaks – if a program does not free memory that is no longer referenced by any object, it can lead to memory exhaustion over time.

Garbage collection seemed like a really good solution to the memory leak issues occurring in low-level languages such as C/C++ but, it had a few CPU issues. CPU usage increases when a significant amount of CPU time is spent in garbage collection. Heap is the memory that is used to allocate memory dynamically as opposed to the stack memory which is used to store the local variables. Local memory is quite automatic and local variables are allocated automatically. An increased allocation rate of objects on the managed heap causes garbage collection to occur more frequently.

Here are a few types of Garbage collectors:

Mark & Sweep GC(Tracing GC): A two-phase algorithm that first marks objects that are being referenced as “alive” and in the next phase frees the memory of objects that are not alive. JVM, C#, Ruby, JavaScript, and Golang employ this approach. JavaScript engines like V8 use a Mark & Sweep GC along with Reference counting GC to complement it. This kind of GC is also available for C & C++ as an external library.

Reference counting GC: Every object gets a reference count which is incremented or decremented as references to it change. Garbage is collected when the count becomes zero. This is not preferred as it cannot handle cyclic references. PHP, Perl, and Python use this kind of GC with workarounds to overcome cyclic references. This type of GC can be enabled for C++ as well.

Automatic Reference Counting(ARC): Similar to Reference counting GC but instead of running a runtime process at a specific interval the retain and release instructions are inserted into the compiled code at compile-time and when an object’s reference becomes zero, it is cleared automatically as a part of the code execution. It also cannot handle cyclic references and relies on the developer. ARC is a feature of the Clang compiler and provides ARC for Objective C & Swift.

Resource Acquisition is Initialization (RAII): Objects and variables are scoped, and an object’s memory allocation is tied to its lifetime, which is from construction until destruction. It was introduced in C++ and is also used by Ada and Rust.

Rust

Rust is a general-purpose systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. It is a multi-paradigm language that supports imperative, functional, and object-oriented programming. Rust is not only used to create low-level systems software such as operating systems, device drivers, and embedded software, but also used to create high-level applications such as web servers, command-line tools, and graphical user interfaces.

Rust builds on RAII( Resource Acquisition is Initialization) to provide automatic memory management. RAII is a programming technique that uses the lifetime of an object to manage the lifetime of its resources. In Rust, the compiler ensures that the memory is freed as soon as the object goes out of scope. This is achieved by the use of smart pointers. Rust implements borrow checking and ownership rules to ensure that memory is freed as soon as the object goes out of scope. Additionally, Rust also provides a garbage collector that can be used to free memory when the object goes out of scope.

Ownership and Borrowing

#[derive(Debug)]
struct Employee {
    id : i32
}

fn main() {
    let a = Employee{id: 43} ;
    let b  = a ;
    // println!("{:?}", a) ; // error: borrow of moved value: `a`
    let c= a ;
    // println!("{:?}", a) ; // error: borrow of moved value: `a`
}

RAII

    fn main() {
        let foo = "value"; // owner is foo and is valid within this method
        // bar is not valid here 

        {
            let bar = "bar value"; // owner is bar and is valid 
            //within this block scope
            println!("value of bar is {}", bar); // bar is valid 
            //here
            println!("value of foo is {}", foo); // foo is valid 
            //here
        }

        println!("value of foo is {}", foo); // foo is valid here
        println!("value of bar is {}", bar); // bar is not valid 
        //here as its out of scope
    }

Rust > C++ ?

C++ is a high-performance, general-purpose programming language that has been widely used for decades. It is known for its flexibility and ability to handle low-level tasks, making it a popular choice for systems programming and game development. C++ also has a large and active community, which means that there are many libraries and resources available for developers to use. Rust, on the other hand, is a relatively new programming language that was first released in 2010. It is designed to be a safe and concurrent language, with a strong focus on preventing common programming errors such as null pointer dereferences and buffer overflows.

Coming back to our questions that we were pondering upon earlier, now we get that compiled languages are preferred over interpreted languages as they are much faster and hence C++/ Go are preferred over Python/JavaScript. While C++ is extremely fast, it is also prone to memory leaks. Other languages such as Rust and Go offer better automatic memory management. Go implements a garbage collector which has a CPU usage overhead while Rust builds over RAII and implements borrow checking and ownership rules to ensure that memory is freed as soon as the object goes out of scope. Rust also provides a garbage collector that can be used to free memory when the object goes out of scope.

Will rust replace C++ anytime soon? No. Rust is a relatively new language and is still in its early stages of development. It is not yet widely used in production, and there are still many features that are missing. However, it is gaining popularity and is being used in many large projects, such as Firefox and Servo. C++ has been widely used for decades and has a vast amount of legacy code, making it difficult for Rust to replace it. C++ has a much larger community and ecosystem, with a wealth of libraries, tools, and resources, making it easier for developers to find help and resources. Rust’s tooling is still evolving and may not be as mature or widely used as C++.

The myth of Sisyphus (II)

Anubhab Patnaik — Sat, 09 Aug 2025 00:00:00 GMT

Previous entries:

Jajabara (I)

The myth of Sisyphus speaks about the futility of life, the absurdity of existence, and the struggle against the inevitable. Growing up, looking for the purpose of life, turning twenty-five, exploring existentialism and quarter-life crisis. Sisyphus, the king of Ephyra, was condemned to roll a boulder up a hill, only for it to roll back down each time he reached the top. This endless cycle of moving to reach a destination that always eludes him mirrors my human experience. Growing up, I found myself packing and moving every couple of years, always searching for a place to call home.

Growing Up

Life in Asansol was a lively experience. The company quarters we moved into were located in a sprawling colony, and my house number was B2/2. The colony was huge, a little universe of its own, with its own customs. It was a mix of people from different backgrounds and cultures, mostly from South and Central East—West Bengal, Jharkhand, Bihar, and Odisha. We traded homemade dishes, celebrated festivals together, and played until the sun disappeared—or until our parents dragged us back home, whichever came first.

I was lucky enough to meet many kids around my age. Together, we formed a large, rambunctious group, though most of them were four or five years older than me. That age gap meant I often served as their errand boy, fetching items or doing other grunt work, but I was happy to be part of the group. Two rival groups prevailed: the men versus the ladies. Each group had four to five members, and we played hide-and-seek, football, badminton, and all sorts of games together. I was one of the younger members and was at the mercy of the older ones. The women bossed me around, always using me in their battles. Men were simpler, but equally provocative in wars. I was the weapon of choice for both sides.

We still had harmony for most of the time. We went to tuitions together, watched TV, shared comics, went on long walks, exchanged game disks and comic books, played IGI, and had fun. Us boys were more focused on comics, sports, and video games. We played badminton, football, and cricket, and usually, the cricket ball would end up in someone’s house, and we would have to beg them to give it back. Every evening we would dash out of the house, knocking and ringing doorbells to bring everyone out to play—without fail, every single day.

On weekends, the colony would come alive with house parties—usually arranged by the girls in our group. All they needed was a little food, some snacks, and a place to sit, and they would plan a host of games I never quite understood. Birthdays were also a big deal; everyone would show up to celebrate, regardless of how well they knew the birthday kid. We played badminton and hide-and-seek frequently. These games were gender-neutral and thus played by everyone.

My family and relatives often visited us. In this new world, where the invisible boundary of the colony defined my universe, my family and relatives were always a joy to have. They brought with them stories, laughter, and love, filling our home with warmth and joy. Their arrival meant less studying, more roaming around, and some petty cash to spend when they left. Now, years later, their memories make me want to rush back home. The memories accompany me making my subway rides a bit more bearable, and my nights a bit more peaceful.

Beyond the colony, there wasn’t much exploration of Asansol itself. Unlike Kolkata, we didn’t go out much; the colony truly was my whole world. At eight, I was starting to understand that there was a larger, more complex society beyond our boundary walls, but the extent of my daily life revolved around my friends and our home. Now, at twenty-four, I watch days pass by, and nights go white with the snow and the world outside—a place where I am yet to find my place.

My school was far away. I remember the bus rides taking an hour to reach the school. My school was like stepping onto a different dimension. It was a Christian Missionary School, Assembly of the God Church, deeply invested in sharing biblical stories and holding long, reflective assemblies. The institution’s strictness was jarring to me at first. It was also huge, boasting two expansive playgrounds and a canteen that sold amazing spring rolls. Academically, I was doing well, scored a 100% in my math exams. I was always good at Math, Science, Grammar, and Literature and terrible at History, Civics, Hindi, and Arts.

My parents put a lot of emphasis on scoring well. This somehow slowly started to shape my life in a way that I would not have actually wanted. I feel children should be left alone to be children, constantly failing and succeeding on their own merit—paving their own way in the world, and not be burdened with the weight of expectations. A lemon now I know what to do with.

Vacations were mostly spent back home. Asansol—and indeed most of West Bengal—came alive in October and November with Durga Puja festivities. Durga Puja has always been the most joyous time for me throughout the years. In all the cities I have lived in, life has always been kinder to me during these few days. We would roam the streets at night, visiting brightly lit pandals and paying our respects to the idol of the goddess, returning just in time for community dinners at the colony tents. In November and December, the winters were chilly, and we couldn’t sleep without a heater. That was also the year we bought our first car—a cherry-coloured Hyundai Getz Prime. We often drove the 500 km to Bhubaneswar, weaving through scenic highways, pausing at roadside stalls, and listening to stories from my parents’ own childhoods, oblivious to what awaited me in adulthood.

Looking back, I realize how simple everything was back then. The world felt small, and the days stretched endlessly. The transient inevitability of the non-linear passage of time was yet to dawn on me. I still don’t truly believe in the concept of linear time. I don’t feel Asansol was just two years of my life. It feels like much longer. Days were longer. Surrounded by family and relatives, life never felt lonely. My sister, who once fit snugly in my arms, is nineteen now. Back then, the world was a playground, and I was the undisputed king of my castle.

Yet, like every chapter before, the boulder couldn’t stay perched on that hill forever. This journey from one hill to another—the ultimate Sisyphean truth—hurt this time. My friends in the colony were gradually being uprooted too—their parents worked in the same organization, which meant one by one, they all had to move on, and I realized the inevitability of this journey. Again, back to square one, we found ourselves with our bags packed. After five odd years of living in a different state, my father got a chance and thought it would be nice to go back to Odisha and live near home. Those years in a different state had raced by. It was time to start over, to push yet another boulder up another hill. But even though leaving Asansol stung, I found solace in the understanding that such is the nature of life: a Sisyphean cycle of endings and beginnings, each one layered with memories, friendships, and lessons I would carry forward.

Back to Roots

I was nine years old now, in 2009, and my parents seemed happy. Moving to Jajpur, a small town in Odisha, meant we were closer to Bhubaneswar, making frequent visits to our extended family much easier. My grandparents were overjoyed; they could see us more often, visiting every weekend and sometimes staying with us for extended periods. This was a welcome change for all of us.

Our new move was peaceful, and we gradually started settling down. I was in fourth grade now and attended Harrow Public School. The school was small, with a playground that was more of a dust bowl. The school itself was housed in a large, unfinished two-story building. The first floor was divided into two sections: a vast hall accommodating four different classes without any partitions, and a smaller room designated for the primary grades—first, second, and third, separated by walls and curtains.

I was introduced to my native Odia language in a more raw form. The prayers, scripts, and literature were a bit difficult for me to grasp since other students had been learning the language for a long time. Despite this, the culture felt personal and heartfelt.

The exciting part was witnessing sixth and seventh-grade students getting disciplined by the teachers. Beating students until they turned red was an essential discipline technique in a rural town. The teachers were strict, and the students were rowdy. The school was a mix of different backgrounds. Some were from the town, while others were from the nearby villages. I was excited since the school allowed students pens in the fourth grade, and that is what mattered to me the most; pen users were the elite, and being able to scribble with a pen instead of a pencil was a significant rite of passage.

Jajpur life was slow, peaceful, and simple. The town was small, with narrow, muddy lanes and small shops, enveloped by paddy fields and empty grounds. The air was rich with the scent of fresh earth and filled with the sound of birds. The evenings were cool, filled with the chorus of crickets, children playing, and temple bells ringing. Nights were serene and quiet. The town was a world away from the hustle and bustle. We rented a house and settled in, making it our home. The weekends were a ride to Bhubaneswar, and the weekdays were spent in school and solitary confinement.

Transitioning from a place where I had countless friends to a new home with hardly any children nearby was a strange and emotionally difficult adjustment. It’s not that I had zero friends, I did have a lot of friends in school, and a couple near my house. There was a disconnect, though, not palpable then, but slightly more evident now. It was my first real encounter with loneliness. The few children who lived near us attended a different school—a more polished institution. In the evenings, I spent most of my time alone, watching TV, playing on computers, or just wandering around the house. The loneliness was palpable, a constant companion that followed me everywhere. Afternoons and evenings passed by, blueish violet skies, and the sun setting in the distance. I would often wait for the sun to set completely and listen to the sounds of the temple prayers blasting on the speaker in a loop. Mostly lucid, I would sit on my bed, just reminiscing about the past, overthinking about the future, and wondering what or where would I be, in 15 years. New York, the US? Careful what you wish for.

I spent most of my time reading and watching TV soap operas. I have read countless books. From comics to Dickens and Tolstoy, I was a voracious reader. I do not remember popular books or prominent series that I read- never read Narnia or Harry Potter, was more into the classics. Tolstoy was a nice read but too polished for my taste. Dickens had this amazing grounded writing style, exploring the human condition much like Sisyphus. I was fascinated by the way he portrayed the struggles of his characters, their resilience in the face of adversity, and their quest for meaning in a chaotic world. These stories resonated with me, lost in pages and in worlds far away.

Other times I was invested in Soap operas, an addict. That was what primarily kept me entertained. And my computer. We got a new computer after moving to Jajpur. I still remember my dad weighing in the pros and cons of assembling a PC and buying a pre-built one. We went ahead with an assembled one. Actually, the loneliness didn’t affect me a lot, unlike how in adulthood it slammed right on my face, anxiety creeping up my spine. Childhood loneliness was a happy loneliness. My mind wandered off to places I had never been, and I was happy to be lost in my own world. Maybe I don’t completely understand this, and although not the most ideal situation- having to spend most of my time alone, I was happy, and at peace. The weekends were a relief, back in Bhubaneswar with all my extended family and cousins.

My favourite memory has to be the journey back home. We would travel in our Hyundai Getz Prime, taking the four-hour drive to Bhubaneswar. The route was picturesque, winding through lush green fields, quaint villages, and increasingly wider roads as we crossed cities. The journey was a time to bond with my family, to talk about lives lived in the 70s, 80s, and 90s, to laugh, and to share stories—a time to reflect and plan for the future, a time to dream, to imagine, and to create. The soundtrack to these memories was the Odia songs from the CD my father bought, featuring the soulful music of Akshaya Mohanty. The same one who sang Jajabara. I still remember the order of the songs and the lyrics, each one etching itself into my memory.

There always felt something profoundly liberating about being on the road, in motion, part of a journey. Roads are a metaphor for life itself—a journey fraught with constant change and uncertainty.

However, our time in Jajpur was brief- a year. Settling down proved difficult, and concerns about education and livelihood began to outweigh the town’s tranquil allure. My parents decided it was best to move to Cuttack, as enrolling in a school in Bhubaneswar mid-year seemed impossible. The following year was spent with me, my mother, and my sister in Cuttack, while my father stayed back in Jajpur to wrap up his term. A new beginning awaited us, a new boulder to be pushed up a new hill. The Sisyphean cycle continued, and I was ready to embrace it.

Leaving Behind the Rural Life

Mother, sister, and I moved to Cuttack. Jajpur and Cuttack weren’t that far apart- a four-hour drive. The move to Cuttack restored a sense of belonging. The city was vibrant, with a rich history and culture. Cuttack is an old city with a diverse population. People from all over India lived there, a melting pot of cultures. The streets were lined with ancient lanes, bustling markets, and the scent of fresh flowers. While Odia was the main language, I also encountered Bengali, Marwari, and other influences daily. The school introduced me to a bunch of new friends and perspectives, and my tuition classes were fun-filled. I was in fifth grade now, and I attended DAV Public School, CDA Sector 9.

Cuttack introduced me to people more my speed. I made some amazing friends, whom I am still in touch with. We spent our days playing cricket, attended tuition classes, and went on school picnics. There was a radical change in the sixth grade. Although we moved to Jamshedpur once my fifth grade was over, before the summer, I spent a month or two in Cuttack. Sixth grade was spent in Sector, was a new ballgame. Sections spanning up to I or J, each holding sixty to seventy students. The school was huge, with a sprawling campus, and multiple playgrounds. I didn’t have a lot of time to explore before we moved. It had these amazing food stalls outside the school, and I remember asking my mother to spare some change every day to get food from there. She obliged because she knew I wasn’t an avid eater, yet, and wouldn’t be able to stand and eat food from the stalls. I took an absurdly long time to finish my food.

Our life in Cuttack was beautiful, always filled with family and relatives, and more than half the time was spent back at home in Bhubaneswar. I made many friends, and living in a city made perfect sense to me. We were there for just another year before my father’s office decided it was time for another ascent, a new life to be built. Bags packed, trucks loaded, sitting in a car watching the city pass by, we found ourselves in Jamshedpur. The year was 2011, and I was in the sixth grade.

Next entries: 3. The 102nd hike (III)

Teasquared

Anubhab Patnaik — Mon, 15 May 2023 00:00:00 GMT

Standing here on the cusp of graduating, gazing upon the halls and pathways that have become my home for the past four years, a swirl of emotions engulfs me. My heart feels heavy with this melancholy as I roam around this campus for the final time. Every nook and corner of this campus holds a special place in my heart. Every memory, every laugh, and every tear have been etched into these walls. And now, as I take my final steps through these corridors, I can feel a sense of separation looming over me. It’s hard to let go of something that has been a part of your life for so long.

The classrooms where we are always late are filled with nostalgia. The same classrooms where we listened to lectures with half attention, where we struggled to keep our eyes open during the post-lunch sessions, and where we made friends. As I stand at the back of the room and look at the empty seats, I can hear the echo of our conversations. The long hours spent with our lab partners, trying to make sense of the experiments, the fear of lab tests, the laughter and the frustration - all of it comes flooding back. Walking past these memories, I feel a sense of loss. I am leaving behind a part of myself.

Silicon Institute of Technology

It feels like only yesterday that I was a wide-eyed fresher, stepping onto campus for the first time. I was, in my mind, a tech hero, filled with adrenaline, prepared to win and rule. As I stepped into the world of the unknown and grown-ups, I realized I had much to learn. I was a small fish in a big lake and had to learn to swim. I was overwhelmed by the sheer number of people, the hustle and bustle of the campus, and the endless possibilities that lay ahead of me. We used to walk around with an ID card hanging and hang out in corners, bragging about how we were going to change the world upon graduating. I remember hopping on the evening bus to visit the market with my friends. We’d eat a ton while discussing the everyday nuances of our college lives. Participating in events, giving out interviews for clubs, helping organize events and hanging out late with seniors were all we did; we were young, naive, and full of dreams.

I yearn to go back to the first year and walk through the gate again. I long to don those ID cards once again and stand with my friends at T-Square as we reminisce about our first-year experiences. I remember getting asked to demonstrate riding bikes, ask a senior’s name in the proper format, and pry on our classmates and get their numbers for the seniors. Pondering back, I wish I could attend classes again, get sent outside for disturbing, run in sweaty formals, enter the chilled CS labs, and sit there staring blankly at the screens. Looking back, I can’t help but smile at the memories.

Skylab

Now that most of my friends have moved on, I miss going to ABD with them, not worrying about the future, and rambling about the terrible college we studied in and the magic we’d have done had we been running the college. I want to keep discussing what we should wear to Zygon and Rythmnova and whether we’ll need to wear our ID cards at night. Walking past the hostel gates, memories flood back of us staying together, sharing each other’s shirts, shampoos, and snacks, and using one hairdryer among two hundred people. The late nights spent in the hostel corridors talking about life, family, the future, movies, and music were magical. The evening’s borrowed speakers ensured that none of us slept. On exam nights, we used to knock on a random room and ask them for a few pointers and questions, and then they wouldn’t know either (well because they are my friends, what else do you expect ? :D) and then we would go down knocking on other rooms, which I will cherish forever.

As we bid farewell to each other, we make promises to stay in touch, meet, and gossip. We know in our hearts that these are sweet, generous lies that we tell ourselves. Life happens. We move on and learn to live without each other.

Filled with bittersweet nostalgia, I reflect on the journey that led me here, the friends I have made, and the experiences I have had. As I pen these words, I want to express my deepest gratitude to my alma mater and everyone who has been a part of my journey. I can’t help but wonder about my choices and the roads I’ve taken during this journey. It has been a time of growth, discovery, and unforgettable memories. I bid adieu to this cherished chapter of my life and reflect on the moments that have made it memorable. My silicontites, I will cherish you for a lifetime. While it is bittersweet to say goodbye to this phase of my life, I eagerly look forward to embarking on a new chapter. With my sights set on new horizons, I am excited to see where life takes me and what the future holds.

Goodbye, SIT ❤️

190310030 Signing Off

Zuzu

Anubhab Patnaik — Sun, 29 May 2022 00:00:00 GMT

Zuzu is a static site generator that takes in markdown files and renders HTML pages. This blog has been written using this generator. This enables noobs like me to write blogs without having to learn a lot of code :P .

⚠️ The latest version of zuzu might not updated in the original codebase, but instead all the features can be found here: anubhavpgit/anubhavpgit.github.io. A couple of features have been added to the original codebase, such as RSS feed, PDF generation, and CSS/JS injection. The better codebase is the one mentioned above❗

Features
How does it work?
Getting Started
Next?

Features

Zuzu builds on a very basic problem statement: I want to start my own blog without having to learn a lot of code. The current version supports a ton of features:

Markdown: Zuzu supports Github-flavoured markdown. Ramble on about your favourite topics, add code snippets, tables, and images, and Zuzu will render them for you.
Syntax Highlighting: Zuzu uses highlight.js to beautify your code snippets. Just add your code in a code block and Zuzu will take care of the rest.
CSS/JS Injection: Zuzu allows you to add your own CSS and JS files. Just add them to the static folder and Zuzu will inject them into your HTML files. Make sure to include the path in the markdown file. Example: ....<link rel="stylesheet" href="/static/css/style.css">....
Front Matter: Zuzu uses front matter to extract metadata from the markdown file. The front matter is written in YAML and is enclosed between ---.

Example:

--- title: 'Zuzu' 
date: "29-05-2022" 
description: "Zuzu is a static site generator that converts all your markdown files into static html pages.
It uses Github-flavoured Markdown CSS and highlight.js to beautify code snippets." tag: "tech" 
---

RSS Feed: Zuzu generates an RSS feed for your blog. Just add the rss.xml file to the static folder and Zuzu will take care of the rest.
PDF Generation: Zuzu uses md-to-pdf to convert your markdown files into PDFs. Just add the pdf link to your markdown file and Zuzu will take care of the rest. Example: Download PDF.
Configurable: Zuzu is highly configurable. You can change the theme, add your own CSS and JS files, and even add your own static folders. The config.toml looks like this:

# Homepage
base_url = "https://anubhavp.dev/zuzu/"

# template
template = "anubhavpgit"

...

# Path to the directory containing the templates
template_dir = "templates/anubhavpgit"

# Path to the directory containing the static files
static_dir = "static"

...

# Theme
templateHTML = "templates/anubhavpgit/template.html"

How does it work?

Zuzu leverages Node.js and a few packages to convert markdown files into HTML pages. It parses the markdown files, extracts the front matter, and converts the markdown content into HTML. The HTML is then injected into a template to generate the final HTML page. The final HTML page is then written to the output directory. The packages used are:

MarkdownIt Markdown parser done right.
MarkdownItAnchor Header anchors for markdown-it.
Glob “Globs” are the patterns you type when you do stuff like ls .js on the command line, or put build/ in a .gitignore file.
Gray-Matter Parse front-matter from a string or file.
Mkdirp Create Dirs if they do not exist.
Path Provides utilities for working with file and directory paths.
Highlight.js Highlight.js is a syntax highlighter written in JavaScript. It works in the browser as well as on the server. It works with pretty much any markup, and doesn’t depend on any framework and has automatic language detection.
MDtoPDF Converts markdown to pdf.
RSS RSS parser.

The generator consists of, but not limited to, the following functions:

slugify: Converts a string into a URL-friendly slug.
readFile: Reads a markdown file, parses its front matter, and renders its content to HTML.
templatize: Replaces placeholders in a template string with actual data.
saveFile: Saves content to a file, creating necessary directories if they don’t exist.
getOutputFilename: Generates the output HTML filename for a given input filename and output path.
getOutputPdfname: Generates the output PDF filename for a given input filename and output path, ensuring the folder exists.
processBlogFile: Processes a blog file, converting it to HTML and optionally to PDF, and updates a map of blog metadata.
processDefaultFile: Processes a default file, converting it to HTML and optionally to PDF.
buildBlogIndex: Builds the blog index from the map of blog metadata and updates the index file.
copyAssets: Copies assets from the source folder to the destination folder.
main: Orchestrates the processing of all markdown files, fetching metadata, and generating the static site.

The script follows this flow:

Initialization: Import necessary modules and define utility functions.
MarkdownIt Setup: Initialize MarkdownIt with plugins for rendering markdown content.
Main Function:
- Define paths for source content, output directories, and templates.
- Fetch metadata from a remote URL.
- Clean and create necessary directories.
- Process markdown files in the source directory, converting them to HTML and optionally to PDF.
- Build the blog index from processed blog files.
- Copy static assets to the output directory. Execution: The script is executed by calling the main function within an async IIFE, handling any errors that occur.

Getting Started

To get started with Zuzu, clone the repository and install the dependencies:

git clone https://github.com/anubhavpgit/zuzu.git
cd zuzu
npm install

This would be a good place to start your markdown files. The content folder contains all the markdown files. The templates folder contains the HTML templates. The static folder contains the CSS and JS files.

To generate the HTML files, run:

npm run generate

You can find two themes in the templates folder: anubhavpgit and initial. To change the theme, change the template in the config.toml file, and the templateHTML in the config.toml file. Zuzu is highly configurable. You can add your own CSS and JS files to the static folder and include them in the markdown file, or better, start with your own theme.

Next?

The zuzu repository is a good place to start. The latest version of zuzu might not updated in the original codebase, but instead you can always find all the features maintained here: anubhavpgit/anubhavpgit.github.io.

I am eagerly looking for someone to migrate all the features to the original codebase. Feel free to ping me if you’re interested.

If you really dig zuzu, I would suggest you try Zuzu out, and then maybe contribute to the codebase. The codebase is open-source and contributions are welcome. Feel free to add comments, issues, or pull requests. Update the codebase, add new features, or even create your own theme. The world is your oyster, and zuzu is your playground.

Current odyssey

Anubhab Patnaik — Wed, 01 Apr 2026 00:00:00 GMT

Current, 2026

Wednesday, April 1

April

Settled in; the city is beautiful, and the weather is amazing, but I am still getting used to it. Most days feel tiring, and a little overwhelming and anxious. SF is calmer, more laid back, naturally beautiful, and has a lot of techies. Still trying to find my groove here, but excited to explore what it has to offer.

March

March brings forth a few bittersweet changes. The sweet part: I am now the founding engineer at Voicebit, a voice-based AI food ordering system :). We are replacing the friction in food ordering by creating an end-to-end voice-based AI system that allows users to discover restaurants, explore menus, and place orders seamlessly.

With this, my journey at Authentic comes to an end. It has been an incredible ride and I’ll forever be grateful for getting to build this. The bitter part about all this is leaving New York.

New York (Technically, the bank of Hudson in Jersey City) has been my home for the past two years, and I have loved every. single. bit. of it. Growing up watching Friends and HIMYM, a life in NYC, living with a bunch of friends, was basically all I ever wanted.

The best thing about New York, at least for me, is the people. NY instantly makes you feel at home. The city is home to a huge diaspora of diverse immigrants. You get to meet a lot of people, and every third person speaks a different language and comes from a different corner of the world. It instills a sense of belonging and stability — “you aren’t alone; see, all these people have also left their own countries and are living here with you.” It just feels like it’s nobody’s home… and everybody’s home. The rent and taxes drive you nuts, but the food, culture, and life experiences more than make up for it.

NY had a ton of magic dust to sprinkle. Getting lost in the lives of people from around the world; walking with friends in the middle of the night; the ramen places always around the corner; the huge slices of pizza; the little deli shops with their sandwiches and energy drinks; the gelatos and cheesecakes; the halal carts and their shawarmas; the traffic and the jaywalking; watching the sunset from DUMBO; the feeling of never being alone because a million people are always walking with you; walking and exploring little nooks and corners with friends, talking about life; the little food festivals; the taco joints and their Indian-flavored tacos; watching the lives of people unfold in the subway are magical.

The weather, although horrible at times, was something I was getting used to. I am not that bothered by the cold, but the gloomy, cloudy weather in winter and spring are unbearable. I am a big-time sun-worshipper, and the beautiful falls and the sweltering summers are some of the most magical days of my life that I will miss dearly.

The yellow hues on my last morning in New York.

I still plan on (or at least will try to) visit New York every month. Can’t stay away for too long.

Ending this on a sweeter note: I am moving to San Francisco! Building and scaling a tech venture studio, SF is the best place to be. I have some experience here from last summer, when I was working at h011yw00d. Excited for what’s next — the unknown and the adventures are what make life worth living.

February

Anubhav @fuzzymfx

A quick fun weekend-project at Authentic!

Friday was fun at Authentic headquarters. We got these sunset lights to jazz up the office vibe.

Reverse engineered the bluetooth signals and built this custom CLI app that monitors production state of our app and can change colors based on CI failures and sentry logs.

February 14, 2026

It’s been a busy start to the year. The weather in New York has been extremely cold in the past month. Today’s high is -9°C and the low is -17°C with gusts making it feel like -26°C. The last two weeks have been extremely busy and productive. I have been working on multiple projects at work, and have been heads down on building.

Running and scaling Luna has been good. Speaking to a couple of potential co-founders and trying out (gambling) a few ideas. The process is fun, but extremely exhausting. Will write about all of this in more detail.

In the current economy, where tech starts underperforming NASDAQ, I have no idea what to expect in the next few weeks. A couple of models later, I think everything I do and think will be obsolete. I’d have to hunt for new jobs. I might try out astrophysics, or philosophy, or maybe even consider farming. Claude and GPT will be taking over the world anytime now.

After the dust settles, I’d like to leave and explore the world for a bit. Spend some time vacationing somewhere warm.

January/ February 1st week contributions look wild

January

Happy New Year! Kicking off 2026 with a renewed focus on personal growth and exploration. The new:

Authentic is now live on both app stores. Excited to see how you guys engage with it! (iOS | Android)
Tried snowboarding for the first time. Loved it. Planning to visit the mountains more often this year. Goal is to do a black diamond run in a year.
Back to focusing on fitness. Set a goal to reach a certain body-fat percentage by mid-year.
Engaged in a few exciting projects at work, including a new AI initiative plus a community platform. More details to come soon.

In other news, excited to launch Luna, my venture studio! Luna is one month old, already generating revenue, has multiple projects in the pipeline, and is setting up a venture of its own. Looking forward to sharing more updates soon.

2025
2024
2023

fuzzymusings

2023, A Year in Review

December

November

October

September

August

July

June

May

April

March

February

January

2024, A Year in Review

December

November

October

September

August

July

June

May

April

March

Feb

Jan

2025, A Year in Review

December

November

October 🎃

September

August

July

June

May

April

March

February

January

Dough - A Rich Presentation Tool

Why Dough?

Features

Unveiling the Core

Contributing

Fall, 2023 - Kedarnath & Dubai

A trek to Kedarnath

Marhaba, Dubai

Ferry - A C compiler for RISC-V

Table of Contents

Compiling High-Level Languages

Machine Code

Computer Architecture

Ferry

Walkthrough

The Subset of C supported

Core

Lexical Analysis

Syntax Analysis

AST

Semantic Analysis

Intermediate Code Generation

Optimization

Code Generation

Assembly and Linking

Instruction decoder

Yatch

Future Work

Fourier Analysis

Table of Contents

Fourier Analysis

Recap

Sinusoidal Waves

A Harmonic Wave:

Functions of Waves and Signals

Wave Interference

Fourier Series

Periodic Signals

Approximating Complex Waves with Fourier Series

Drawing with Fourier Series: Epicycles