9 July 2019 – Final year Computer Science students Yang Suwei and Song Zhiwen, with final year Computer Engineering student Paul Tan, received the Outstanding Undergraduate Researcher Prize (OURP) for Academic Year 2018/2019.
The annual, university-wide competition encourages NUS undergraduates to pursue exciting research opportunities and recognises exceptional undergraduate researchers for their work. Suwei, Paul and Zhiwen were awarded the prize for their Final Year Projects (FYP).
Fighting forest fires before they happen
Suwei received the prize for his project on using historical satellite images to predict forest fires in Indonesia. He was co-advised by NUS Computing Assistant Professor Kuldeep Meel and NUS Department of Geography Assistant Professor Massimo Lupascu.
“Indonesia has a lot of peatland forests which release large amounts of carbon dioxide when burnt,” said Suwei. “I wanted to test the feasibility of using machine learning methods and historical satellite images to predict forest fires one month ahead of time. If it is possible to predict forest fires, precautions can be taken to mitigate potential fires.”
While working on his project, Suwei developed various versions of neural networks to learn from satellite image histograms and then to create their own predictions on the following month’s projections. Over the course of the year, Suwei sought the advice of organisations like the World Wide Fund for Nature Singapore and the NUS Centre for Remote Imaging, Sensing and Processing (CRISP) to develop his project. According to Suwei, there was no known existing machine learning models for forest fire prediction at the time he started the project. “Our neural networks performed better than expected and we believe that with more refinements and work, this project could be a feasible method for combating forest fires.”
“It was a pleasant surprise to have won this award. I have seen many impressive projects from my peers and it is truly an honour to receive this recognition for the effort given to this project,” Suwei added.
Making real-time scaling possible
Zhiwen, supervised by Assistant Professor Richard Ma, won the prize for his project on designing and implementing dynamic scaling in stream processing engines. Stream processing is a technique for processing data directly as it is received. With stream processing, data insights can be provided within milliseconds to seconds.
As stream processing engines constantly receive data, they need to dynamically readjust their computational resources to meet the changing workload in a real-time environment. “When traffic spikes, scaling out is needed to ensure throughput and latency,” said Zhiwen. “However, existing systems are unable to scale in real-time and require users to manually restart the application. Once the application starts running, it is impossible to scale in or out during the runtime.”
Zhiwen’s project started out as a way to understand the interaction between an open-source stream processing engine Apache Samza and its resource management system YARN. To make dynamic scaling possible, Zhiwen developed a scaling component—which he named the Decision Maker—to request resources from YARN during the engine’s runtime. “In the final rounds of testing, Decision Maker was able to scale out the Samza application during its runtime and so it improved the performance of the applications. It was truly satisfying to see my component smoothly integrated with the existing system and achieving its expected results,” Zhiwen added.
Designing a programming system that designs programs
For his FYP, Paul, supervised by Associate Professor Chin Wei Ngan, developed a metaprogramming system for C programming language. Metaprogramming is a programming technique where computer programs treat other programs as their data. This allows for the program to read, generate, analyse or transform other programs.
“Metaprogramming is interesting because it has been used successfully to implement new powerful features in other programming languages without modifying the compiler and to embed domain-specific languages,” explained Paul. “This enables larger, more complex programs to be written correctly with less time and effort.”
Over the course of the year, Paul developed a metaprogramming system that allows users to write metaprograms as though they were writing a normal C program. “Most metaprogramming systems place restrictions on users, such as requiring users to use a separate meta-language,” Paul added. “C is a widely used programming language that still lacks a powerful metaprogramming system, so having such a metaprogramming system would be very useful.”
After trying out many variations, Paul managed to design and implement a small metaprogramming system that is made up of an unrestricted compile-time evaluation system and a low-level compiler API. “We could progressively build abstractions on top of it to allow metaprograms to be written in an expressive manner and implement new programming language features,” said Paul.
“The chance to work on my own project idea made the setbacks so much easier to handle because it gave me a greater understanding of the problems and helped satisfy my own curiousity,” said Paul. “Ultimately, being able to work on a self-proposed FYP is a very unique experience and I’d encourage others who have their own ideas to go for it.”