Research Award Opportunities

One of the most valuable research experiences for an undergraduate student is to be a research assistant. Each year, the department receives a number of research awards that help provide funding for an undergrad student to spend 16 weeks over the summer working full time in one of the department’s research labs, often with the opportunity to publish their work (see examples of previous projects.) This kind of research experience is highly sought after by graduate programs.

All applicants must confirm their eligibility to apply and to work. You must have all necessary requirements prepared (ex. Social Insurance Number and permits).

International students must have a valid Social Insurance Number and be eligible to work on campus for the duration of the award (ex. in the summer). you will be required to provide any necessary details and documentation upon accepting the award (SURE or WLIUR). This is necessary for processing and payment. If you are offered an award but do not meet this criteria, you will not be able to accept. For questions about eligibility, please speak with an International Student Advisor.

Award Categories

The positions are available to 2nd, 3rd, and 4th year students with strong academic records. You'll find more information about the awards available, including eligibility requirements below. Watch for in-class and email announcements from the department for details and deadlines.

NSERC USRA

NSERC Undergraduate Student Research Award

NSERC Science Blog

SURE

Science Undergraduate Research Experience Award

WL IURA

Work Learn International Undergraduate Research Award

Work Learn International Undergraduate Research Award Science Blog

Additional Resources

NSERC Site

UBC Careers Site

Eligible UBC Grant Holders in the Faculty of Science for NSERC USRA 2025 - 2026

FAQ for Summer 2025 WL IURA

How to Apply

Deadline: February 7, 2025 at 4:00 PM (Extended to February 12, 2025 at 4:00 PM)

New Application Requirement: all applicants are required to apply with a confirmed supervisor. The list of projects and supervisors will be posted on this page, and you can use this to approach any of the supervisors listed. However, you aren't limited to the projects and supervisors listed below. We encourage you to directly contact professors you would like to work with to find a match. Many professors will be happy to talk to you about the opportunity to hire students at a subsidized wage. You can find our faculty directory here. For some additional tips, please see the UBC Careers page.

Required Steps:

Read the details above and the information at the links on this page
Determine which awards you are eligible for
Contact potential supervisors from the Projects and Supervisors list (see below) or by approaching Computer Science faculty members you would like to work with
Once you have a confirmed supervisor, submit the online application webform by the stated deadline (the webform will become available before the deadline):
- Before submitting, please ensure that you have read over the online guidelines, eligibility requirements, and webform instructions carefully
- Make sure to read all of the instruction text in the webform, there may be important details noted below each field
When the department is informed of how many awards are available, a departmental adjudication committee will rank the applications based primarily on the student's academic record. All applicants will then receive a decision. If you are selected for an award, you will then receive an email with instructions to submit a new webform to provide additional information/documentation:
- When you are applying: please read the webform carefully to ensure you are prepared to accept by providing these details
- (Your supervisor will also be contacted for required information)

IMPORTANT:

All students should complete the NSERC Form 202 on the NSERC USRA website by clicking "On-line System Login" or, if you are a first-time user, "Register"
All students should upload a PDF of the completed NSERC Form 202 to the online application webform
DO NOT submit the application on the NSERC website until you have been accepted for the award and instructed to do so (at the end only students awarded for NSERC USRA will submit the application to NSERC website)
Instructions on how to complete the forms can be found on the NSERC USRA website

Questions? For further details, please visit the UBC Student Services website or the NSERC USRA website and review the information and links provided, as these will likely give you the answers to your questions. If you would still like additional assistance, please see our Advising Webform instructions to see if you are eligible to submit a webform request.

Projects and Supervisors: Summer 2025

Alex Summers

Contacts: Zack Grannan ( zgrannan@cs.ubc.ca ) and Alex Summers ( alex.summers@ubc.ca )

Project 1: Static Program Analysis for Rust Async Runtimes

Static program analysis techniques identify guaranteed program behaviours fully automatically without the need to execute the program. They are widely used in IDEs and CI/CD for detecting potential program bugs and in compilers for program optimizations.

Rust is an emerging system programming language whose type system provides stronger guarantees to programs such as memory safety and data race freedom. By leveraging the information from Rust’s type system, we can potentially build more advanced static program analysis to assist complex tasks like automating program verification.

In this project, you will be working on a research project called Raven. Raven is a verification tool aiming to verify the correctness of Rust async runtimes (i.e., libraries that support running async programs in Rust, such as tokio) such that no async computation ever gets lost or hangs forever. Raven only requires minimal user input by leveraging static program analysis to automate its verification. You will be working on enhancing Raven’s static program analysis framework which is the backbone of the verification automation.

Student Responsibilities:

Explore the current support for static analysis in the Rust compiler.
Refactor Raven’s static analysis framework.
Design and implement backward abstract interpretation for Raven’s static analysis framework.
Add test suites to evaluate the correctness and performance of the backward abstract interpretation.

Qualifications: Basic understanding of the Rust programming language. Some basic knowledge about static program analysis, abstract interpretation, compilers is preferred but not required.

Expected learning outcomes: You will gain in-depth knowledge about how the Rust compiler works. You will also get hands-on experience with the Rust programming language and the implementation of abstract interpretation and static program analysis.

Work Setting:

On-site (UBC Vancouver Campus)

Project 2: Using Symbolic Execution for Automating Rust Verification

Symbolic execution is a program analysis technique that steps through a program by treating all the user inputs symbolic rather than obtaining concrete values as normal program executions. Symbolic execution is traditionally used for generating testing inputs that enter specific paths of the program.

Rust is an emerging system programming language whose type system provides stronger guarantees such as non-aliasing. The additional information provided by Rust’s type system enables symbolic execution to be more precise and thus capable of assisting more advanced tasks such as automating program verification in Rust.

In this project, you will use a state-of-the-art symbolic execution engine in Rust to extract value information about Rust programs, and integrate that to Raven, a verification tool aiming to verify the correctness of Rust async runtimes. The goal of the project is to use the symbolic execution to enhance automation in Raven’s verification. You will also have the opportunity to extend the symbolic execution engine for more complete support of the Rust programming language.

Student Responsibilities:

Explore the Rust symbolic execution engine and integrate it into Raven.
Improve Raven’s current static analysis by using the symbolic execution engine.
Identify Rust features that are not well supported by the symbolic execution engine, and add support to some of them.
Evaluate the performance/precision improvement brought by the symbolic execution.

Qualifications: Basic understanding of the Rust programming language. Some basic knowledge about static program analysis and compilers is preferred but not required.

Expected learning outcomes: You will gain in-depth knowledge about Rust’s memory model and the internals of Rust compiler. You will also get hands-on experience on Rust programming and implementing advanced static program analysis using symbolic execution.

Work Setting:

On-site (UBC Vancouver Campus)

Project 3: Domain Specific Language for Reliable eBPF Programming

Extended Berkeley Packet Filter (eBPF) is an emerging technology for safely and efficiently extending the OS kernel using user programs without the need to modify the kernel source code. The safety of eBPF comes from an in-kernel verifier that performs a collection of static program analyses and rejects programs that potentially interfere with the kernel negatively (e.g., crashing the kernel).

Despite eBPF’s intriguing superpower, writing eBPF programs is notoriously hard. This is because the in-kernel verifier sometimes rejects safe programs due to the limitation of static program analysis. In addition, eBPF programs have many implicit restrictions that are opaque to programmers, such as features only accessible to certain kernel versions or functions only accessible to certain types of kernel extensions.

In this project, you will explore how to make eBPF programming more reliable by designing a Domain Specific Language (DSL). You can explore many different aspects of improving eBPF programming experience, such as providing additional information to assist the in-kernel verifier, providing more intuitive error messages to make debugging eBPF programs easier, generating eBPF programs that are more efficient, etc.

Student Responsibilities:

Explore the current usage and programming patterns in eBPF programming and identify the critical safety/security issues.
Working with a PhD student on designing a DSL that addresses some of the identified issues.
Implement a prototype of the DSL and evaluate its efficacy.
(If time permits,) formalize the syntax and semantics of the DSL.

Qualifications: Experience in system programming. Basic knowledge about eBPF and programming language design and implementation is preferred but not required.

Expected Learning outcomes: You will gain in-depth knowledge about eBPF. You will have hands-on experience of designing and implementing a DSL, and potentially formalizing its syntax and semantics.

Work Setting:

On-site (UBC Vancouver Campus)

Project 4: Formalizing eBPF ISA

Extended Berkeley Packet Filter (eBPF) is an emerging technology for safely and efficiently extending the OS kernel using user programs without the need to modify the kernel source code. eBPF is being quickly adopted in industry to support high-performance networking, enhanced system observability, advanced profiling, and so on.

Due to the growing adoption of eBPF, eBPF’s instruction set architecture (ISA) is being standardized and released as a RFC in Oct. 2024. As a first step of making eBPF programming reliable, it is desirable to have such standard formalized. The formalization of eBPF ISA can be used for proving soundness of the eBPF verifier, testing the conformance of eBPF runtime implementations, etc.

In this project, you will work on the formalization of a part of the eBPF ISA using a proof assistant (e.g., Lean, F*) or a verification language (e.g., Viper, Dafny). You may also explore proving the soundness of simple static analyses done on the eBPF ISA.

Student Responsibilities:

Study the current RFC for eBPF ISA.
Formalize a critical part of the ISA using a proof assistant or verification language.
Formalize the semantics of the ISA.

Qualifications: Experience in proof assistants or verification languages. Basic knowledge about eBPF is preferred but not required.

Expected Learning outcomes: You will gain in-depth knowledge about eBPF. You will have hands-on experience of formalizing a low-level language and doing proofs using a proof assistant or verification language.

Work Setting:

On-site (UBC Vancouver Campus)

Project 5: Optimised Verification Condition Generation for Rust Verification

Program verifiers are tools that can ensure strong correctness properties about software. Prusti is a program verifier for Rust developed in collaboration between UBC and ETH Zurich; it can be used to guarantee, for example, that a given Rust program will not crash, or that a Rust program satisfies a user-provided specification. In contrast to competing deductive verifiers, which translate Rust programs to pure functional programs, Prusti translates Rust programs to the imperative intermediate language Viper, thereby preserving the heap-manipulating semantics of the original Rust program. Unfortunately, reasoning directly about Rust program memory in Viper is not efficient, and as a result Prusti performs poorly compared to other Rust verifiers.

However, many Rust programs are written in the so-called safe subset of Rust, which imposes restrictions on how memory can be accessed. For such programs, the full generality of Viper is not necessary to model heap memory. Based on this observation, we have recently developed a prototype version of Prusti that performs verification more efficiently by instead reasoning with a simpler memory model for safe Rust programs.

The high-level goal of this project is to further expand this line of research beyond our prototype by developing a more efficient encoder for safe Rust programs that can be integrated into Prusti. In particular, one disadvantage of the current prototype verifier is its reliance on an unoptimized custom-built symbolic executor for Rust. For this project, you will investigate an alternative approach that translates Rust programs into Viper, while still using a simple memory model for safe Rust. This approach will take advantage of the existing high-performance symbolic execution engine for Viper, which we expect will result in more efficient verification. As part of the project, you will also evaluate the performance of this approach against other existing state-of-the-art Rust program verifiers such as Creusot and Aeneas.

Student Responsibilities:

Design and implement an optimized encoder for Safe Rust programs in a program verifier
Evaluate the performance of the optimized implementation compared to competing verifiers
Collaborate with graduate students and other collaborators on development, with weekly meetings to discuss issues and present progress

Qualifications: Experience with the Rust programming language. Familiarity with programming language concepts such as compilers and type systems.

Expected Learning outcomes: This project will provide an exposure to a collaborative research environment and provide an opportunity to gain experience with tools such as SMT solvers and deductive verifiers. In addition, the project will also allow you to deeply explore the Rust programming language, type system, and implementation. During the project, you will work closely with other students involved in the Prusti project, and participate in the development of a real-world program verifier.

Work Setting:

On-site (UBC Vancouver Campus)

Arpan Gujarati

Project 1: Software-controlled inverted pendulum with redundancy and reinforcement learning

A software-controlled inverted pendulum (see https://en.wikipedia.org/wiki/Inverted_pendulum for reference) is a cyber-physical system that requires continuous control to remain in a stable vertical position. Any problem with the control — software or hardware issues, even transient delays — will cause the pendulum to fall. We consider a software-controlled inverted pendulum as a representative example of more complex control systems in safety-critical applications, like inside cars and drones. We have a work-in-progress testbed (see https://github.com/ubc-systopia/inconcretes/tree/physical_ivp for details) consisting of an inverted pendulum and a fault-tolerant quadruple-modular redundant system to control the pendulum. The goal of this project is to extend our existing work on with seamless transition between fault modes as well as the use of reinforcement learning (RL) for controlling the pendulum as an alternative to classical PID control.

Student Responsibilities:

The student’s first task is to get familiar with our existing setup and repositories, and get the control system to work (which may require reconfiguring the hardware components). The student's second task then is to ensure that all fault modes (already implemented) work well in isolation. The student’s third task is to then ensure that fault introduced at runtime do not break the system, but the system can withstand these. Finally, the student will also work on using RL as an alternative controller for the system (this can also be done first depending on the student interests).

Qualifications:

While the research corresponds to designing software systems primarily, and the hardware challenges in our testbed are mostly sorted, we expect the candidates to be comfortable working with the various electro-mechanical components in our testbed. It would be nice if the candidates have some background on distributed systems or reinforcement learning or control system. It is preferred, but not expected, that the candidate also possess some knowledge of real-time systems or operating systems scheduling. C/C++ skills are recommended.

Work Setting:

On-site (UBC Vancouver Campus)

Project 2: Re-engineering a fault-tolerant architecture for heterogeneous MPSoCs

Heterogeneous embedded platforms, such as the Zync UltraScale+ MPSoC, are increasingly being used to program safety-critical cyber-physical systems applications. We are especially interested in their real-time capabilities, as they possess separate real-time processors (ARM Cortex-R family) in addition to application processors (ARM Cortex-A family). The goal of this project is to identify design patterns for fault-tolerant real-time distributed systems on such heterogeneous processors.

Student responsibilities:

Given an implementation of a fault-tolerant distributed real-time system — such as systems like IGOR (https://par.nsf.gov/servlets/purl/10282881), In-ConcReTeS (https://arpangujarati.github.io/pdfs/rtss2022_paper.pdf), or Cascade (https://haeberlen.cis.upenn.edu/papers/cascade-rtas2020.pdf) — the student will work on refactor the design to work on a distributed system where each node is a heterogeneous platform. Specifically, the student we reengineer one of the above systems, say, In-ConcReTeS, on the Zync UltraScale+ MPSoC test bed and redo all the experiments from the paper to generate a new baseline.

Qualifications:

The project will require understanding and working with open-source implementations of existing research prototypes, redesigning and reimplementing them (if needed), and porting them to the new platforms. The secondary goal will be an empirical evaluation of the new system design against the old one. We expect the candidates to ideally have some background on distributed systems or real-time systems or operating systems. C/C++ skills are strongly recommended.

Work Setting:

On-site (UBC Vancouver Campus)

Project 3: Response-time analysis of a soft real-time NVIDIA Holoscan application

NVIDIA Holoscan SDK is a novel edge and embedded software development framework designed for NVIDIA System-on-Chips (SoCs), primarily targeting medical device applications. This SDK facilitates complex data processing workflows using Directed Acyclic Graphs (DAGs) composed of functional units termed operators. These operators, running in separate threads, are usually interconnected with intricate execution dependencies influenced by both upstream and downstream conditions on communication data buffers. Current methods to measure the response time of a complex Holoscan application rely on empirical benchmarking, which can be costly, time-consuming, and unreliable – limitations that are particularly critical in sectors where safety and certification concerns are paramount. We introduced a novel static analysis methodology to determine worst-case end-to-end response times in NVIDIA Holoscan applications.

Student Responsibilities:

We are looking to compare our work with various types of synchronous dataflow graph abstractions proposed in the literature. The student will require to do literature survey, identify suitable baseline candidates, implement these algorithms, and compare them with our current analysis. The student will also assist another PhD student in the design of an exact response-time analysis.

Qualifications:

The project requires understanding of algorithms and data structures and a bit of statistics. Since the algorithms need to be implemented and evaluated against our analysis, the student also needs to have some background on Python/C/C++ programming.

Work Setting:

On-site (UBC Vancouver Campus)

Project 4: Empirical profiling of NVIDIA Holoscan for different edge computing applications

Student Responsibilities:

We want to evaluate the feasibility of using NVIDIA Holoscan for various different edge computing applications, such as deploying an autonomous car pipeline on top, or deploying the latest DeepSeek model on it. The student will carry out a thorough fine-grained empirical profiling, including that of the GPU interactions, of the different workloads to assess the feasibility of incorporating them in time-sensitive pipelines.

Qualifications:

The project requires a thorough empirical measurement and profiling of workloads. The student must have a strong background in programming with C/C++ and must be comfortable playing with Linux CLI, installling packages and running Docker containers, setting up software from scratch, etc. Overall, the student should seem motivated for systems research.

Work Setting:

On-site (UBC Vancouver Campus)

Project 5: Using Lingua Franca to model fault-tolerant distributed real-time systems

Lingua Franca (LF) — https://www.lf-lang.org/ — is a coordination language for specifying embedded systems at a high level using an actor-reactor model. It is designed to formally reason about timing in a distributed real-time system. It also allows mapping an application written in the form of a high-level specification to a low-level C/C++ implementation. The goal of this project is to use LF to model a fault-tolerance protocol for a distributed real-time system, for one or more control applications, so that the timing correctness of the protocol implementation can be verified at the specification level, as opposed to at the implementation level.

Student Responsibilities:

The student will need to learn this new high-level language LF, which has language bindings in Python/C/C++, and then understand existing literature on couple of different relevant fault-tolerance protocol, and then implement these in the language. Finally, the student will translate the specification to a real implementation and test them on real hardware.

Qualifications:

The student must have some experience with algorithms and data structures and must be comfortable with mathematical reasoning. Experience or knowledge of distribute systems or fault tolerance or real-time systems is a plus, but not necessary. Since the final step is an empirical evaluation, the student must be comfortable with low-level languages like C/C++. To work with LF, the student must be comfortable in Python as well.

Work Setting:

On-site (UBC Vancouver Campus)

Dinesh Pai

Project 1: Measuring Hidden Human Motion

This project focuses on measuring how human subjects move, offering a unique opportunity to work with cutting-edge measurement technologies in the Sensorimotor Systems Lab. You will gain hands-on experience with world-class facilities, including 3D body scanners, motion capture systems, and the newly developed electromagnetic sensor system ("Measuring Human Motion Under Clothing," SIGGRAPH Asia 2024, https://dl.acm.org/doi/10.1145/3680528.3687702).

This innovative system has been used to assess the performance of athletic apparel in collaboration with a major Vancouver-based clothing brand, and your research will build upon this work, exploring new directions.

Student Responsibilities:

You will participate in research activities, develop research prototypes, attend research meetings, and write reports.

Qualifications:

The ideal candidate enjoys interacting with people, designing and conducting experiments with human participants, and analyzing complex datasets. Attention to detail is paramount to ensure the highest quality data collection.

Work Setting

On-site (UBC Vancouver Campus)

Project 2: Learning to Simulate Physical Objects

This project involves applying advanced machine learning techniques to efficiently simulate complex physical objects, such as the human body and clothing. You will work with both large third-party datasets and unique, high-quality data collected in our lab. Collaborating closely with experienced Ph.D. students in the lab, you will leverage your expertise in machine learning, computer graphics, and scientific computing to develop novel simulation models.

Student Responsibilities:

You will participate in research activities, develop research prototypes, attend research meetings, and write reports.

Qualifications:

A strong background in Computer Graphics and/or Machine Learning.
Strong software development skills are essential, as you will utilize popular Python machine learning frameworks alongside NVIDIA's Warp Python framework for spatial computing on GPUs.
This project is ideal for candidates who excel in problem-solving, are passionate about simulation and machine-learning technologies.

Work Setting

On-site (UBC Vancouver Campus)

Frank Wood

Project: PLAICraft - Embodied AI

** Please submit your resume, a cover letter outlining your research interests, relevant experience, and a transcript to plai-admin@cs.ubc.ca **

Imagine a future where you can talk to a computer program in a virtual world like Minecraft, and it responds and acts like a real person. That's the goal of our project: to create an advanced artificial intelligence (AI) that not only understands speech but can also respond and act within a complex virtual environment. This type of AI is known as embodied AI, which means it can think, act, and learn in a simulated or real-world setting, just like humans.

We aim to collect thousands of hours of data to train and develop an advanced AI, and we are already well on our way! Our platform and project are up and running with a ton of collected data and users. If you’re a motivated individual, come join our team!

Student Responsibilities:

Develop and enhance the front-end user interface and other interactive components.
Write, debug, and optimize code, focusing on Minecraft plugin development and integration.
Work with cloud computing platforms to manage large-scale data collection, storage, and processing pipelines.
Document code, processes, and project progress to support our project practices and contribute to continuous improvement.

Preferred Qualifications:

Understanding of principles of systematic design and academic experience in computer programming.
Proficiency in Java programming, with experience in developing and working with Minecraft plugins.
Familiarity with front-end development, including HTML, CSS, and JavaScript frameworks.
Understanding of cloud computing concepts and experience with AWS.
Strong problem-solving skills and the ability to debug and optimize software for performance and scalability.
Interest in artificial intelligence, machine learning, and virtual environments like Minecraft.

Work Setting:

On-site (UBC Vancouver Campus)

Joanna McGrenere and Vered Shwartz

Project: Designing a voice-based AI banking tool for older adults

With increasing online banking and declining cash use, financial technology (fintech) must support barrier-free participation in everyday economic activities. For older adults with cognitive diversity, artificial intelligence (AI) assistance in online transactions could enhance autonomous financial participation, but these applications must maintain privacy and security. Our prior work has investigated the potential viability of increased AI support (notably, voice assistants), but considerable work is needed to actualize AI assistance in online banking.

To advance AI support in the context of fintech and aging, this project addresses the research question: How can a voice-based AI tool support older adults in online banking tasks? We identify the design requirements of voice-based AI assistance in online banking and then design and evaluate an interactive proof-of-concept prototype of an online banking voice assistant to advance AI-assisted fintech support in aging.

Student Responsibilities:

The student will work with two faculty members and a postdoctoral fellow to design, develop, and refine a voice-based natural language processing (NLP) prototype. The online banking setting offers a controlled environment to mitigate common challenges with general-purpose personal assistants or automatic speech recognition (ASR), such as handling speech impairments, different accents, and background noise. Leveraging off-the-shelf speech-to-text services (e.g., Microsoft Azure) and other NLP applications (including those powered by LLMs), we can employ grammar error correction to decipher ambiguous utterances and sentence embeddings to map utterances to the descriptions of predefined banking tasks, even when participants use different words.

The student will have additional opportunities to apply human-computer interaction (HCI) methods. They will build a mock-up online banking interface as the application context of the prototype and benefit from feedback and pilot testing with lab members.

Qualifications:

Students interested in working on this project must have done CPSC344 and CPSC436N. Prior HCI experience (beyond CPSC344) is a plus but not a requirement.

Work Setting:

On-site (UBC Vancouver Campus) , some online work is allowed.

Karon MacLean

Project 1: Modelling a Computational Framework for Analyzing Time Series Data

Role: Data Science Research Assistant

*Note: Please email spin-info@cs.ubc.ca with your application package. Applications sent to Prof. MacLean directly will not be considered.*

Our lab is seeking a highly motivated and talented undergraduate student to join our research team as a Research Assistant. The successful candidate will be crucial in developing and implementing a robust data analysis and computational modelling framework for interpreting touch, movement, and physiological data. The analysis will be in time series, frequency, or any other applicable latent domain.

Student Responsibilities:

Develop and maintain Docker-based analysis template containers:
- Pre-install essential data science libraries (Python, Pandas, NumPy, Scikit-learn, etc.)
- Include common data preprocessing, visualization, and statistical analysis tools.
- Document and maintain the container and its associated scripts.
Assist in the design and development of data analysis workflows within the containerized environment.
Explore and implement machine learning algorithms, including deep learning models, for potential future applications.
Contribute to the documentation and dissemination of research findings.

Qualifications:

Undergraduate student in Computer Science, Mathematics, Cognitive Systems, Engineering, Data Science, Statistics, Neuroscience, or a related field.
Strong programming skills in Python.
Familiarity with data science concepts and tools (e.g., Pandas, NumPy, Scikit-learn).
Strong understanding of Docker and containerization principles.
Experience with version control systems (e.g., Git) is a plus.
Excellent analytical and problem-solving skills.
Strong communication and teamwork skills.

Work Setting:

On-site (UBC Vancouver Campus)

Duration:

May - August 2025

Note: Interested candidates can start as early as February as a research volunteer

To Apply:

Please submit your resume, a cover letter outlining your research interests, relevant experience, and a transcript to spin-info@cs.ubc.ca.

Project 2: Investigating an Affective Haptic Robot as a Comforting Haptic Co-Regulating Agent in Cognitive Reappraisal

Role: Research Assistant

*Note: Please email spin-info@cs.ubc.ca with your application package. Applications sent to Prof. MacLean directly will not be considered.*

We developed a prototype of a CHORA, a “comforting haptic co-regulating adjunct” by adapting our lab’s existing haptic robots (simple, expressive, low-cost and physically robust) and adding our recently developed soft multichannel affective touch sensors to study its implications on emotion regulation processes. Our team is evaluating this CHORA’s role in facilitating cognitive reappraisal for emotion regulation, particularly in understanding the pathways through which this effect permeates.

Our lab is seeking a highly motivated and talented undergraduate student to join our research team as a Research Assistant. The successful candidate will have a research aptitude, strong problem-solving and organizational skills, and experience in conducting human subject studies and analyzing both qualitative and quantitative data. An interest in human-robot interaction, affective haptics, and emotion regulation will be considered an asset.

Student Responsibilities:

Support data collection for an in-lab study, including participant recruitment, developing study instruments, experiment setup, and data recording.
Assist in the setup and maintenance of hardware and software systems required for the study.
Design and develop data analysis workflows under supervision and contribute to the data analysis (both qualitative and quantitative).
Contribute to the documentation and dissemination of research findings, including preparing reports, presentations, videos, and manuscripts

Qualifications:

Currently enrolled undergraduate student in Computer Science, Mathematics, Cognitive Systems, Engineering, Psychology, Statistics, Neuroscience, or a related field.
Have taken CPSC 344, 444 or an equivalent HCI course.
Have previously conducted user studies in course projects or any other capacity
Familiarity with qualitative data analysis workflows, methods, and tools.
Experience with version control systems (e.g., Git), and familiarity with Python programming skills is a plus.
Excellent analytical and problem-solving skills.
Strong research aptitude, communication skills, with the ability to document work effectively and collaborate with a multidisciplinary team.

Work Setting:

On-site (UBC Vancouver Campus)

Other Opportunities:

Independent Candidates will have the opportunity to:

Explore their research questions nested within the main project as a mini-project.
Have the experience of a complete research cycle, from study design to data analysis, under the guidance of a senior graduate student.

Duration:

May - August 2025

To Apply:

Please submit your resume, a cover letter outlining your research interests, relevant experience, and a transcript to spin-info@cs.ubc.ca.

About the Lab:

SPIN is an interdisciplinary group of researchers who design and build innovative physical, touch-based user interactions to solve real problems for real people. We study and design for human perception and affect, considering both interface usage and the process of designing them. We are concerned with what these interfaces will do, how they will work, the way they'll feel, sound and look; and how users will perceive them.

These interactions are finding their way into clothing and mobile devices, robots, furniture and the walls of your home; into expressive applications where current interaction mechanisms fail, like computer music handlers and media control; therapeutic tools which leverage emotional, responsive touch; sensorially overloaded environments, like car interiors; and into the language and tools we use to create touch-based applications themselves.

SPIN people come from many backgrounds -- human-computer interaction, machine learning, robot design, visual arts, mechatronics, psychology, and music -- and learn from each other.

Kevin Leyton-Brown

Project: Predicting Human Strategic Behaviour in Video Games

Strategic interactions, in which multiple self-interested agents interact with each other, have been traditionally modelled using game theory–a mathematical framework describing how agents should behave when faced with a strategic decision. These idealized models rely on unrealistic assumptions about these agents, including their rationality, computational power, and access to information. Behavioural game theory (BGT) attempts to avoid making such unrealistic assumptions by learning models of human strategic behaviour from empirical data. However, past BGT work has focused almost entirely on datasets from psychology experiments, which have limited scope and are miniscule compared to modern machine learning datasets.

In this project, we aim to use replays from real-time strategy games, such as StarCraft, as a new source of data on human strategic behaviour. These games provide highly structured, complex environments where players are intrinsically motivated to perform well. A primary challenge of this work is that replay data contains information on both high-level strategic decisions (e.g., which units players built) and low-level actions (e.g., where players clicked on the screen). Thus, we plan to develop abstractions of these replays, representing player's high-level strategies while discarding low-level actions. These high-level abstractions will allow us to evaluate and create theories of human behaviour on a much larger scale than before.

Student Responsibilities:

Work closely with two graduate students to develop replay abstraction algorithms (e.g., using clustering methods)
Implement and run abstraction algorithms on large replay datasets
Fit existing behavioral game theory models to abstracted datasets
Attend weekly group meetings to present and discuss progress

Student Qualifications:

The student should be experienced with programming in Python and working with Unix systems. Experience or interest in machine learning and statistics (especially with PyTorch), game theory, and real-time strategy games is a plus.

Work Setting:

On-site (UBC Vancouver Campus)

Laks V.S. Lakshmanan

Project: Dynamic MoE-Driven Ensemble of LLMs: Cost-Efficient Query Routing and Speculative Decoding for Scalable Inference

In this project, the student will develop a dynamic, cost-efficient ensemble framework for large language models (LLMs) using a Mixture of Experts (MoE) approach to optimize inference costs while maintaining high performance. Unlike prior work that statically pre-selects LLM subsets, the framework should feature a neural router that dynamically assigns queries to the most suitable LLMs based on their complexity.

To prevent over-reliance on large models, a Load Loss term should be introduced that balances query distribution across models. Additionally, a speculative decoding-based aggregation technique will be used, where encoder outputs from multiple LLMs are combined using a weighted sum, and the model with the highest routing score serves as the primary decoder, assisted by speculative decoders to refine predictions.

This approach reduces computational costs while preserving response quality. The framework will be evaluated on NLP benchmarks (e.g., GLUE, MixInstruct, WMT) using task performance, inference cost, and cost-quality trade-offs, with comparisons against prior work such as HybridLLM, ThriftLLM, and FrugalGPT. Ultimately, this research advances the scalability and efficiency of ensemble LLMs, making them more practical for real-world deployment.

The proposed research is relevant to responsible AI. Specifically, it will cover the aspects of
democratizing AI by making deep learning more efficient, less expensive, less compute, and
energy-intensive without compromising performance.

Expected Contributions from the student:
1. A novel dynamic routing mechanism for LLM ensembles that adaptively selects models based on query complexity.
2. A cost-aware loss function that balances computational load across the ensemble.
3. Integration of speculative decoding, enabling efficient and compatible ensemble outputs.
4. Comprehensive evaluation demonstrating significant cost reductions without compromising performance.

Students from Year 2 or higher are welcome to apply. However, prior research experience
involving deep learning is highly desirable.

Student Responsibilities:

The student will have weekly meetings with me where we will discuss problem formulation and refinement as well as strategies for model design, model pruning, as well as efficient model routing and aggregation strategies.

Qualifications:

The student should have an outstanding academic record and ideally have prior research exposure to solving problems using deep learning with basic background knowledge in NLP and familiarity with modern deep learning and LLM frameworks.

Work Setting:

On-site (UBC Vancouver Campus)

Margo Seltzer & Swati Goswami

Project: Network Function Caching on Programmable Switches

Network Functions such as firewalls and Network Address Translators (NATs) suffer from poor performance, because they are deployed using software modules running on commodity hardware. We propose accelerating these Network Functions using programmable networking
hardware. More specifically, we implement an in-network cache using programmable switches to improve throughput and latency of Network Function deployments.

The in-network cache implementation presents an interesting design space and our goal is to quantify the trade-offs of different implementation options. The design space includes several parameters such as cache size, associativity, update rate, and the effect of limitations of programmable devices on the choice of caching policy.

Student Responsibilities:

Implement a cache using programmable networking devices.
Integrate the cache with our caching policy. Make modifications / improvements to the caching policy as necessary.
Measure the performance of the prototype deployment with and without cache. Metrics that we will measure include cache hit rate, latency, and throughput of the overall deployment.
Generate varied workloads for evaluating the prototype.
Analyze the collected data, and document the report.

Qualifications:
The student should have taken CPSC 317. Experience with C/C++ is also an added bonus. Please note that we are not looking for prior experience with programming networking devices. We will provide all the necessary background information and tutorials for programming specialized networking hardware.

Work Setting:

On-site (UBC Vancouver Campus)

If you are interested, please contact Swati at sggoswam@cs.ubc.ca

Reto Achermann

Project 1: Modeling Serverless Workloads

Function-as-a-Service (FaaS) is a way to deploy applications in the cloud. Developers simply write their function logic and upload it to the cloud provider. When a request comes in, the cloud provider then takes care of setting up a new execution environment, running the function, and sending back the results. There are many design decisions involved in building such a FaaS system. For example, which host to run the function on, how long to keep the execution environment around to handle a repeated invocation quicky, or how many functions to run concurrently. Evaluating the effects of these and other design decisions is challenging and costly as it requires many different application scenarios.

Instead, to answer these questions we built a customizable simulation infrastructure that lets us play around with various parameters and algorithms that define how these function requests are routed and executed on a system. The goal of this project is to advance the state of the simulator to increase its fidelity, support for various workload scenarios, different algorithms.

Student Responsibilities:

Work together with two faculty members and external collaborators.
Attend weekly meetings to discuss and present progress
The student will advance the python-based simulator and identify, design, and implement evaluation scenarios to help answer questions about the simulated system architecture.

Qualifications:

Excellent ability to write python
Good understanding of computer systems.
Completed Systems Courses at UBC: e.g., CPSC 313 / 317 / 436A

Work Setting:

On-Site (UBC Vancouver Campus)

Project 2: Verifying Parts of SQLite

SQLite is a widely used database and used by a broad variety of applications on servers, operating systems, smart phones, and even smart watches. SQLite stores its data in a database file. Updating this file correctly under any possible crash scenarios is important to ensure consistency and prevent data loss. SQLite uses a log-based scheme to record updates to its database file and transactions to ensure consistency.

In a previous project we have been looking into using a verification approach in Coq and a framework Perennial. This required rewriting the transaction manager in Go to make use of the tooling. Now, we would like to revisit this choice and either explore tooling to either verify the original C-code or see to use a Rust-based approach including a rewrite of (parts) of SQLite in Rust.

Student Responsibilities:

Work together with faculty members and possible external collaborators.
Attend weekly meetings to discuss and present progress
The student will advance work with verification toolchains.

Qualifications:

Understanding of verification and proofs.
Ideally, knowledge of verifiers (e.g., Isabelle/Coq/Dafny/Verus)
Good understanding of computer systems.
Completed Systems Courses at UBC: e.g., CPSC 313 / 317 / 436A

Work Setting:

On-Site (UBC Vancouver Campus)

Project 3: Verified Memory Allocator for Compartmentalization

Memory allocation is a critical component for any software system. Applications dynamically allocate memory to hold their data structures. Typically, memory allocation happened at the granularity of a process. Unfortunately, a process is no longer the unit of isolation, as subsystems and libraries are compartmentalized, i.e., isolated from each other. Each compartment has its own memory access rights. This poses a challenge for memory allocators, as there is no longer a single heap per process, but rather a collection of per-compartment private heaps, and shared heaps that are accessible from multiple compartments. More about compartmentalization: https://arxiv.org/pdf/2410.08434

In this work, we will be looking into specifying the properties of such a memory allocator in a theorem prover and reason about the guarantees. The properties should imply or directly prove higher-level systems properties such as confidentiality and integrity. Finally, we will be proving that a simple memory allocator satisfies the specification.

Student Responsibilities:

Work together with faculty members and possible external collaborators.
Attend weekly meetings to discuss and present progress
The student will specify the properties in a theorem prover (e.g., Verus)
The student will implement or adapt a memory allocator and prove that the implementation upholds the properties.
Reason about the performance and memory consumption of the allocator

Qualifications:

Understanding of verification and proofs.
Ideally, knowledge of verifiers (e.g., Isabelle/Coq/Dafny/Verus)
Good understanding of computer systems, in particular memory allocation
Completed Systems Courses at UBC: e.g., CPSC 313 / 317 / 436A

Work Setting:

On-Site (UBC Vancouver Campus)

Project 4: Lingua Franca for Hardware Interactions

Lingua Franca (https://www.lf-lang.org/) is a framework to build time-sensitive, concurrent, and distributed systems. Instead of writing code directly requiring developers to reason about concurrency, distributed protocols, and communication, with Lingua Franca, developers write their application in a higher-level abstraction. This, by construction, eliminates a large class of synchronization problems.

Interactions with hardware are yet another form of concurrency. Even a single, normal computer today looks more like a distributed system under the hood: devices and accelerators are independent actors that communicate with each other through messages.

In this work, we will explore the use of the Lingua Franca model regarding interactions between software and hardware. Explore its limitations and features in this context.

Student Responsibilities:

Work together with faculty members and possible external collaborators.
Attend weekly meetings to discuss and present progress
The student will implement software-hardware interactions in LF, explore the features and limitations.

Qualifications:

Good understanding of computer systems, in particular computer architecture, operating systems, devices
Ideally, background in modeling
Completed Systems Courses at UBC: e.g., CPSC 313 / 317 / 436A

Work Setting:

On-Site (UBC Vancouver Campus)

Thomas Pasquier

Project 1: Provenance-based Intrusion Detection

We are actively developing advanced mechanisms to detect intrusions in computer systems. One promising approach involves leveraging provenance graphs, which represent system execution as a graph structure. By applying graph learning techniques to streaming graphs, we aim to enhance intrusion detection capabilities. You can find our latest research here: USENIX Security 2025 Paper.

In this project, students will investigate state-of-the-art systems, focusing on understanding and explaining why they succeed or fail. To support this work, we have developed a comprehensive benchmarking platform that students can utilize to test and validate their ideas.

This project operates at the intersection of three key areas in computer science:

Machine Learning
Systems
Security

We are looking for motivated and well-rounded students eager to contribute to cutting-edge research and drive the field forward.

Student Responsibilities:

You will participate in research activities, develop research prototypes, attend research meetings, and write reports.

Qualifications:

You need a background in Machine Learning and Systems. Good Python programming skills and familiarity with ML frameworks are necessary.

Work Setting:

On-Site (UBC Vancouver Campus)

Project 2: Preventing the exploitation of unpatched bugs with eBPF

Linux is an open-source operating system kernel with over 26 million source lines of code. Bugs in the Linux kernel need to be addressed as soon as possible to mitigate the risk of potential exploits. However, this is not the case in practice, as a recent study shows that bugs live in the Linux kernel for an average of 1,800 days before they are fixed. Even after bug fixes are committed, it takes time for the patch to be widely distributed. This delay in addressing the bug and deploying the patch to real-world systems creates a window of opportunity for adversaries to exploit the bug. Therefore. the goal of this project is to prevent adversaries from exploiting unpatched bugs within this window.

In this project, students will investigate and understand the bug reports from syzkaller, a well-known kernel fuzzer that continuously tests the Linux kernel for new bugs, and generate eBPF programs that detect and prevent the exploitation of reported bugs.

This project operates at the intersection of three key areas in computer science:

Systems
Security
Fuzzing

We are looking for motivated and well-rounded students eager to contribute to cutting-edge research and drive the field forward.

Student Responsibilities:

You will participate in research activities, develop research prototypes, attend research meetings, and write reports.

Qualifications:

You need a strong background in Systems and Programming. Good command of C and (x86) assembly is necessary.

Work Setting:

On-Site (UBC Vancouver Campus)

Previous Undergrad Research Awards

Last Updated

January 30, 2025