I am Nidhi Jaju

Chromium Project Contributions

Languages Used: C++, HTML, CSS, Javascript, Perl Data Language

As a part of my software engineering internship at Google, I have had the chance to contribute to the open-source Chromium project. Initially, my initial project was to mitigate Chrome crashes happening in DevTools and chrome://serviceworker-internals when a user has too many service worker registrations.

Initially to get used to contribute to Chromium, I helped my manager on his ongoing project to move the service worker storage to use a mojo interface. I have also been working on improving the code health of the service worker codebase, such as using preferred data types, changing to less thread hopping, and removing unnecessary data structures among other things.

My main project became much bigger and higher priority when more bug reports starting coming in, which showed that the crashes were not only happening in DevTools and the internal page, but also on browser startup which was alarming. We found the root function causing the issue, which was retrieving all registrations. I have been working on changing all the relevant call sites and use cases of this function, by writing design docs and making changes to how these registrations are read based on how the information is used. Most of these changes will be included in Chrome M85/M86.

Working on such a big open-source project like Chrome has also been an invaluable experience in itself because of the fast-paced nature of how things change. I have also been privileged that I have gotten to work on a project that became high priority, as well as, getting the opportunity to have my work reviewed by some very important people in the company.

See more about contributions at: Chromium CLs

NLP Inference Engine

Languages Used: F#, .NET Core, Fable

This was a third year group project as part of the High Level Programming module. Our task was to create a large software project using Microsoft’s functional language F# in .NET Core environment. Our project was self-proposed; as we had an interest in Artificial Intelligence, especially Natural Language Processing, we decided to create an inference engine using predicate logic (a formal logic framework).

My main individual part was to create the Parser and Abstract Syntax Tree for the inference engine. This required pulling on knowledge from my Language Processors module as well as effectively using my knowledge of F# that I had gained through the HLP module. As we introduced more and more grammar to our system, I had to take into consideration how the input and output of my part would work as well, to be able to effectively communicate with the logic evaluation modules that would come later on. I defined Discriminated Union struct types, manipulated lists and maps, and learned to use the Expecto test framework to perform unit testing on my code for robustness. Finally, as a group, we designed an Electron Fable app to interact with our back-end modules.

Overall, this project was a good way to combine interests and knowledge from several different modules as well as deepen my knowledge of using functional languages such as F#.

See the source code for this project on Github here.

Mumono (IoT Project)

Languages/Technologies Used: Python, ReactJS, Firebase, RasberryPi

This was a third year group project as part of the Embedded Systems module. Our project brief was to create an IoT device and advertise it to a target audience, and hence it was a highly fun, innovative, and creative project. We decided to tackle the problem of the harmful effects of secondary smoking on infants. Our IoT device detects harmful gases e.g. CO2 and send alerts to the parent/guardian via a web application. As we wanted to make our product a little more diverse, we added some more functionality such as by including an accelerometer for fall detection, and a temperature sensor to measure the body’s temperature. As it would be unsafe and undesirable to attach a device to a baby, so we advertised our product in the form of an IoT onesie embedded with the sensor devices.

We used a RasberryPi to interface with the sensors, and used HTTPS to interact with our app which was hosted on Firebase. We also had to create a marketing website along with video and presentation for our peers. I really enjoy designing webpages and posters so it was a good experience to be able to use my graphic design skills to create a visually appealing marketing plan for the audience. I also started an instagram account to further enhance our social media presence throughout the process as you would with any new startup.

It was a great experience to get a more overall feel for how to create a product as it included planning, designing, implementing, and marketing.

See the source code for this project on Github here.

C90 Compiler

Technologies Used: C++, Flex, Bison, Bash, Command line

This was a second year pair project as a part of the Language Processing module, and was essentially an extension to the MIPS Simulator project. The focus of the project was to design a compiler that could translate given C code into the equivalent MIPS assembly. We also had to provide an automated test suite which would automate the compiler testing process. Furthermore, we had to design the lexer, parser, and code generator.

I learned to use Flex to create the lexer which generates tokens for every matching regular expressions found. We used Bison to write the grammar for the functions in the parser and build our Abstract Syntax Tree (AST). The last part, the code generator, was the biggest challenge; transforming the AST into equivalent machine code required manipulation of data and in-depth understanding of stack operations.

Our main design decision was to treat the MIPS CPU as a stack machine rather than as a register based CPU, to avoid any issues with managing the contents of the registers. We decided to do this as the compiler would not be marked on performance, but rather only for accuracy. The main challenge we faced was trying to get the memory allocation on the stack to work correctly. However, in the end we were able to successfully implement a C90 compiler according to the project specification.

As an additional deliverable, we also had to create a C-to-Python translator, which only supported a limited number of C features, so that we could better understand how to lex C code to a much simpler Python.

Building this compiler was definitely a huge milestone in my software engineering career, and it was definitely very rewarding as I learned a lot.

Project source code on Github: C90-to-MIPS-Compiler

MIPS CPU Simulator

Technologies Used: C++, Bash, Command line

This was a second year pair project as a part of the Computer Architecture module. It was designed to use our knowledge from our lessons to build a CPU simulator that executes binary files based on the MIPS assembly language rules according to the Instruction Set Architecture. We also had to provide a testbench for the simulator to run unit tests on each command supported by our or any other simulator, which endedup consisting of over 250 tests.

One of the challenges that we faced was trying to understand the MIPS ISA, especially the LWL and LWR instructions which would read read a character from stdin. However, in the end we were able to successfully implement all 52 instructions (R, I, and J types) as per given specification for the project and were able to pass all of the assessed tests. We also had to simulate the load delay slot which is caused by the MIPS pipelining, which was done by adding a second program pointer that would decrypt the next instruction whilst the other was running.

Overall, this project was very challenging and time-consuming, but was very rewarding and enjoyable as well. Working on building this simulator was one of the biggest software projects I had completed until then, and the fact that we had to write a testbench really helped us to set milestones as we progressing through the projects, which is an important skill for all of my future projects.

Project source code on Github: MIPS-Simulator

SwypeKey (Virtual In-Air Keyboard)

Technologies Used: FPGA, C, Vivado, Quartus

This was a first year group project as a part of the Engineering & Design module, which was designed to introduce us to Field Programmable Gate Arrays (FPGAs). Along with learning how the device operates and runs, we had to apply our learning within a short time frame to show how we understood the key concepts of image overlay, and real-time image processing such as edge and color detection. We were given full autonomy to research, execute, and deliver the project in our groups. As a group, we decided to implement a real-time virtual keyboard that a user can type on in the air with their finger.

The four main components of our system were color detection, keyboard implementation, processing the intention of users, the the typing output. After careful considerations of how we could implement each component and using decision matrices to help us, we came to the following decisions. We decided to use HSL values for color detection as that would be used for an increased accuracy and better representation of the color spectrum, which would ultimately lead to better tracking of the finger. The target hur and minimum saturation values, which were inputted through the ARM processor via Jupyter, pass through the FPGA to process the colors to obtain the x and y coordinates of the finger’s position on the screen. For the keyboard overlay, we implemented a transparent overlay on the FPGA. By implementing it on the hardware directly, although it used some resources, it allowed for a great frame rate. To register the intention of users, we wanted to initially implement detecting a user-drawn circle around the desired key, but due to time constraints we had to resort to using the button on the provided FPGA. Lastly, we decided to implement the typing itself on the ARM CPU as it would not use resources on the FPGA and thus slow it down, and it was much easier to implement as well given the time constraints.

Through this project, we were able to succesfully create a virtual in-air keyboard. the user can use a brightly-colored sticker on their finger to help track its movement as it pushes keys on the virtual keyboard. The FPGA then processes this data and with the help of the ARM CPU, outputs the letter that was typed. Although we were not able to implement everything we had planned to initially, such as drawing a circle to indicate the user’s intention to type on a key, the basic concept was still accomplished with high standards.

There was a steep learning curve about the nature of the FPGA, how powerful it actually was, and how the different directive on Vivado HLS affect the system. For example, we learned that although pipelining loops may use a lot more resources on the FPGA, and therefore it should theoretically make the system less efficient, testing it on Jupyter shows us that this in fact leads to higher frame rate, which is ultimately better for the user. This is because more processes can happen in parallel if a loop is unrolled and pipelined. We learned that there are different data types that can be sent to the FPGA, and were cautious about using the most efficient types from the very beginning, to yield better hardware optimisation. Not only that, certain errors will not display until we tested and implemented it on Jupyter, this created backlogs to discover which areas had failed for example, inputting two 32 bits using one bus line.

In general, despite these difficulties, a working final product was created that achieved all the basic design specifications outlined in the beginning. The final product has a video output with a keyboard overlay on top. Furthermore, a highlight of the letter which the finger is above is shown in the output along with any letters previously outputted by the user.

Mastermind

Technologies Used: C++, Command line

This was an individual first year software project as a part of the Software Engineering I module. The project was designed to introduce us to and apply our knowledge gained from weekly lab sessions, especially data structures such as hash maps, vector operations, and structs. It is written purely in C++ and can run on the command line with some user input parameters to run game algorithms. This project also had a competitive element as the fastest timed solutions scored the highest marks. I also wrote a report to explain our approach, design decisions, and evaluation based on time-performance metrics.

In the game, the user must provide an input for length and the sequence of code to be tested. It then generates a random sequence of numbers defined by the input length with numbers ranging from 0 to N. The solver then tries to find the optimum sequence using the minimum number of attempts and receives feedback on its guess through the form of black/white hits like the traditional game.

Through this project, I learned about gaming algorithms such as Knuth's, minimax, and max parts algorithms. I had to compare the performance for different algorithms and choose the best one which is an important software engineering skill.

Project source code on Github: Mastermind-game

2048

Technologies Used: C++, Command line

Designing this 2048 game was an individual first year coursework project for our Software Engineering I module, based on the popular game of the same name at the time. It was designed for us to apply our knowledge based on our weekly lab sessions, especially related to data structures such as vectors, arrays, and lists. The code is purely written in C++ and you can play the game from the command line using the keys w, a, s, and d for up, left, down, and right respectively. We were provided a full declarative spec for functions and their signatures, and we had to follow the specification to implement relevant methods because our code would be tested with an automated testbench. The game is designed in a way that the user can load a pre-configured grid as a .txt file or a default 4x4 grid with all zeros and a single 2 in the bottom right corner would be used.

As this was one of my first big software projects, I learned to break them into smaller, more manageable tasks such as the functions. We also had to make the game as robust as possible by thinking about edge cases the game could have. I also had the opportunity to think more about the logic and use paper and pen to draw out what was happening especially since this was one of the more complex projects I had done at the time. Furthermore, I was also able to learn key debugging skills as well as improve my understanding of the data structures.

It was a great experience to get a more overall feel for how to create a product as it included planning, designing, implementing, and marketing.

Project source code on Github: 2048-game

NaSoPod

Technologies Used: Phase Change Materials, Prototyping, Vernier Temperature Sensors

The NaSoPod is a renewable energy heater made up of five aluminium capsules utilising a mixture of phase change materials, making it an unconventional heater. You can bring it out during the day so that it can absorb thermal energy from the Sun, and bring it back inside at night to heat up a given room as it releases thermal energy. This function allows the NaSoPod to heat up a room to 18ºC without electricity. A room temperature of 18ºC is deemed suitable for healthy people by the World Health Organization.

The NaSoPod does not use electricity or fuel, and is completely reusable. This will help to reduce the use of fossil fuels, which is necessary in improving the environment because the use of fossil fuels produces an enormous amount of greenhouse gases: according to the World Resources Institute, humans have added 2.3 trillion tons of carbon dioxide in the last 200 years, and half of it was added in the last 30 years. We need to start changing to other sources of energy immediately, and the NaSoPod can serve as a step forward in the right direction.

We designed this product as a part of the Conrad Spirit of Innovation Challenge and were invited the NASA Kennedy Space Center as Top 5 Finalists in the Energy and Environment category. Furthermore, we wont the overall Power Pitch award based on our pitch to investors at the final competition. As a result, we were able to file a patent application and a company even reached out to us to help commercialise the NaSoPod.

Watch our pitch here: Conrad Final Pitch