Lane Detection : WatonomoVision
Anish Chopra, Jason Milasincic
With a majority of new vehicles sold today featuring driver assistance technologies such as collision avoidance and lane departure warning systems, the idea of a self-driving car is not all too far off on the horizon. These systems, particularly in vehicles designed for operation without a driver, require computationally intense calculations and decision that need to be made instantaneously. While autonomous vehicles are emerging in the automotive market, SAE International and General Motors have partnered to introduce the AutoDrive Challenge, where teams of students from eight universities across North America compete in building a level 4 autonomous vehicle. At Waterloo, the WATonomous student self-driving car team consists of over 100 members, each with an integral part in helping the team succeed in the Challenge. Our team, WatonomoVision, completely redesigned the lane detection stack by using deep learning to tackle the problem. We trained a deep neural network to generate segmentations from a camera image, labelling each pixel in the image as belonging to a lane line or not. This model will be run on an FPGA in the car, which has been specially customized for this task, in hopes of giving us a performance boost over running it solely on the CPU. After this step is complete, our system performs post-processing to generate second-order polynomial representations for each lane line. Finally, we expose these lane lines to the rest of the vehicle’s autonomous system, futher being consumed by the path planning subsystem to allow the car to stay centered in its lane. In the field of computer vision, deep learning has consistently been shown to outperform traditional image processing techniques, as such, we are confident that our system will give WATonomous a competitive edge in future competitions.
Address Querying and Routing for WATonomous
Jacob Moore, Siyi Shen, Richie Shi, David Luo, Victor Duan
For a self-driving car to navigate from one location to another, the car has to both find the coordinates of the locations and create a path between them. While the self-driving car WATonomous has created for the AutoDrive challenge can detect lanes and perform actions on a small obstacle course, it still lacks mapping software to perform routing.
Our project aims to aid WATonomous in building a mapping solution capable of completing the second-year challenges provided by the AutoDrive challenge. This involves the ability to accurately query for a location using multiple address formats, as well as providing routing capabilities between two locations.
A solution used to compete in the first-year challenges exists, but the solution has several issues. Location querying is missing some locations, and is unable to parse certain address formats. The UI also loaded extremely slowly, as it would load every single attribute in the entire database. The entire database would be loaded whenever any action was taken, whether it be a point query or zooming into the map. The solution also lacked routing functionality, the main challenge of the second-year challenges
Our team has decided that building a new product would be the best avenue to solve the problems with the first-year solution, while providing a solid foundation for us to implement the path routing. We have implemented a multi-database solution that performs faster point queries and handles a wider variety of address formats. We have also optimized the UI to not load the entire database, greatly increasing the performance. Most importantly, we have implemented full routing capabilities compared to the previous solution used for the first-year challenges. We are hopeful that WATonomous decides to move forward with our solution for the third-year challenges, when mapping is to be integrated into the self-driving vehicle.
WATOSCENGEN : UnrealGoose
WATOnomous is one of eight student design teams in North America that participate in building self-driving cars, as part of the SAE AutoDrive Challenge. The car, a Chevrolet Bolt, has to be thoroughly tested to identify possible use cases that can be worked on and improve up until the actual challenge in Michigan. This project generates 3D environments, as test scenarios, to ensure the car’s main controller functions in different conditions and edge cases.
This project must generate different 3D environments that can be used in WATOnomous’ own simulation program where the environments are suitable for the actual challenges SAE puts in the AutoDrive competition. It must be integrated into the team’s own simulation program for these scenarios to be used right away.
WATOSCENGEN is built using Unreal Engine 4, a C++ game engine developed by Epic Games. Procedural generation techniques, such as Perlin noise, are utilized to create the landscape, the roads, and the points where the road signs and road marks are placed. This module uses randomization and the pipe-and-filter architecture model to build the environment in order, which is then loaded into the actual simulator to test the car in it. As this is an experimentation project, MATLAB is utilized as well to allow the mock-up car recognize the environment setup.
WATOSCENGEN is tailored towards WATOnomous’ expectations. This module keeps the scope of the scenarios being generated to an arbitrary set that’s similar to the test track in Michigan, but not set up the same way as the actual challenges. Unlike existing simulators, which are built for the general public, this one fits the existing simulator WATonomous has, which includes a mockup of the car. It also takes into account the mock-up build of the car’s LIDAR, path prediction, and feedback systems.
Our minimal expected result is to have an initial-level prototype that generates at least one suitable scenario for WATonomous to use. An optimal expected result is for this to be in production and be part of WATonomous’ critical operations.
Breast Cancer Research with MSHoloLens
Michael Bahng, Jiaqi Qian, Pranaab Dhawan
Breast cancer is the most commonly occurring cancer among women, and with over 2 million new cases worldwide in 2018 it is the second most common form of cancer. Current surgical procedures have complications that result in imperfect treatment; one quarter of women treated for early stage breast cancer must undergo repeated treatments and mastectomy to remove residual tumors. Improving the accuracy of breast-conserving surgery is an active area of research that spans multiple disciplines.
One such complication with the current procedure is that MRI scans of the breast are taken in prone position, but the patient is moved into a face-up position during the surgery. The location of the tumors, accounting for possible warping and displacement, must be correctly determined during the surgery.
Our project aims to extend Dr. Oleg Michailovich’s research on breast-conservation surgery to solve this complication, using Augmented Reality to assist the surgeons in locating tumors. Using proprietary surface projection and reconstruction algorithms in conjunction with the Microsoft HoloLens, which is equipped with various sensors and AR capabilities, we aim to project a 3D hologram of the tumors from a breast MRI, while accounting for changes in anatomical position.
Currently the system implemented on the HoloLens is not performant enough to render images in real time and is unable to fit a surface using the gathered points. Our goal is to create a framework that can scan the 3D surroundings, reconstruct and register the viewed MRI surfaces efficiently, and project a 3D surface at the aligned position in real time using the Microsoft Hololens.
ORB SLAM : SlamDunk
Harkamal Jot, Michael Marek, Pritham Marupaka
One of the main technical challenges in the development of autonomous driving software is knowing a vehicle’s surroundings and its location within them. This problem, known as Simultaneous Localization and Mapping (SLAM), has been an active area of research in recent decades.
Current SLAM solutions make extensive use of image processing techniques to find key points in images, a process known as feature extraction. These techniques predominantly rely on heuristics to alter, segment, and identify coordinates of interest. While the accuracy of such methods is lower than what a human can achieve, the resulting algorithms are fast and easy to add to a SLAM system. One notable algorithm is Oriented FAST and Rotated BRIEF (ORB), which was developed by OpenCV Labs and is known for its accuracy and performance.  (https://ieeexplore.ieee.org/document/7219438)
Because the ORB-SLAM2 algorithm, developed by Raul Mur-Atal et al. at the University of Zaragoza, is designed to work in any unknown environment (without any prior knowledge), it is highly practical but also more prone to errors when identifying objects. For the purposes of the SAE AutoDrive Challenge, which WATonomous competes in, we’re allowed to make certain assumptions about how signs, lane markings, and other objects look. Our group’s aim is to incorporate this information into ORB-SLAM2 to make better key point predictions. The results from our augmented algorithm will provide valuable insight into how WATonomous can improve their existing SLAM algorithm for future competitions.
Real-Time Environment and Path Visualization
Sadman Kazi, Samuel Wu, Justin Li, Shan Phylim
Autonomous vehicles collect and generate an enormous amount of data in order to understand the world around them and how they should behave. This includes raw data in the form of sensor readings, inferred and fused data such as the identification of lane lines or obstacles, and computed data such as the optimal path to drive along. A major challenge in developing and tuning algorithms for the vehicle’s navigation is understanding what the vehicle “sees” at any point in time.
Some of the subteams have previously built out graphical tools using custom libraries for their own needs, but WATonomous recognized the importance of having a cross-team “single source of truth” display which would unify visualization efforts and could be used during live runs for testing and debugging purposes.
Our solution consists of a highly decoupled and customizable module which creates a 3D view of the sensed and computed environment. This module subscribes to data streams over the network from other computation and sensor modules. It performs any transformations required to shift everything into the global coordinate system and then creates visual representations which are buffered until the next frame is ready. The visualizer is also compatible with recorded sensor data, so it can be used for offline testing and rendering. If the computation modules are running at the same time that the data is replayed, the visualizer can reconstruct all details just as they would appear live.
Significant effort was put into performance optimizations to ensure that the visualizer would remain scalable and performant in real-time applications regardless of the environmental complexity. These optimizations include rate-limiting the visualization to match incoming data rates, delta-encoding changes to reduce information over the network, and batching similar geometric elements into a single render request.
Controlling procedural modelling interactively
Tammy Liu, Abhishek Madan, Paul Bardea, Andrew McBurney, Dave Pagurek
Procedural modelling has been an essential tool in the 3D artist’s toolbox for many years, used in applications such as games and movies. It provides a way to add a level of detail and richness that would be impractical to create by hand.
Context-free grammars provide a convenient way of encoding the structure of such patterns. While it can produce great results, the challenge with grammar-based procedural modelling is efficiently sampling the model space to produce a broad range of interesting results while also excluding unfavourable results.
We aim to provide a useful probabilistic search function that can be run at interactive rates to enable the short feedback loops artists require for incremental, exploratory design. We present a constraint for use with probabilistic sampling where artists draw curves, and a model that aligns with the curves is generated. These guides allow us to produce a final model in 200ms that is of comparable quality to those which were generated in 45s using existing methods. This is accomplished by reformulating the search problem so that it operates on the inherent skeletal structure of grammar-generated models rather than examining vertices, pixels, or other concrete artifacts of the model. We also present a real-time model editor to demonstrate the artistic utility of our method.
Learn more about your neighbourhood
Bilal Akhtar, Saksham Sachdev, Nakul Pathak, Naren Srinivasan
Team Abode is working on a web-based data visualization and query tool for data from various public data sets like the Canadian census, city open data sets, etc. We want to give researchers, journalists, and the general public an accurate way to understand their neighbourhood, their community, their city, etc as well as trends about its evolution.
Data that will be presented includes things like basic demographic info, transportation/commute patterns, future housing developments, schools with associated enrollments/capacities, etc. Both absolute data (eg. 3200 people under 15) as well as relative comparisons (eg. 5th fastest growing neighbourhood in the city) will be presented. We hope to indirectly address hysteria about the growth and future of a place through accurate and effective presentation of data.
Neighbourhoods could be compared on how similar their indicators are (eg. age breakdown), and how their future growth projections and trends compare. Both the ability to see a numerical score of similarity, as well as a list of neighbourhoods that are most similar, will be implemented.
We expect the initial user base to consist mostly of enthusiasts in the field as well as people evaluating neighbourhoods to move to. We will gain this market share through publishing tweets and blog posts about our product and having them shared in urbanist circles. Over time, we expect the academic community as well as the media to use our tool as a quick way to understand and compare neighbourhoods and cities on key trends and indicators.
Suadeo: Recommendations from friends
Mart van Buren, Gillian Maducdoc, Maria Kang, Noah Guld, Karel Casier
When visiting or moving to a new city, it’s not easy to discover restaurants, bars, coffee shops or tourists attractions beyond Googling “to do in New York”. People want personalized results. Tools that improve the discovery process of a new city are incredibly useful to users. Furthermore, tools like this help new and unique businesses flourish by helping them reach their target audience, keeping cities lively and fun to explore even after living there for many years. Tools such as Yelp and Google Maps have drastically optimized the way that people get connected with great experiences, but we believe there is still much room for improvement.
When deciding where to go for your anniversary dinner, or where to visit on your next trip to Paris, the experience is usually suggestions from total strangers writing online reviews. While better than exclusively sticking to places you know, we believe this is far from the best solution. We believe the best source of recommendations for great experiences is your friend who lived in Paris for 2 years, or your foodie colleague who knows exactly what food you like. If you’re discovering a new city, the best place to get recommendations is from a friend, colleague or family member that knows you, and has been through the same discovery process before.
If you frequently travel to New York City and now a close friend of yours is planning their trip there, Suadeo is the ultimate way to share your experiences and suggestions. Whether it’s your favorite restaurants for an affordable dinner, or the best coffee shops to get some work done, Suadeo helps connect people with great recommendations. For those that love discovering new places, Suadeo is a tool to express yourself and document great experiences. For those that love restaurants they can count on, and experiences that are reliably great, Suadeo is a tool to discover these places from people they trust, and that have similar taste. Suadeo reintegrates personality into recommendations.
Initial deployment of the minimum viable product was done during the last work term. Based on user feedback and product testing, we are doing a second iteration to improve the experience. Our main focus is on a redesign of our app, and dramatically improving the sharing functionality.
Extracting Counterexamples from TCMC
George Gao, Mitchell Kember, Lynn Tran
Model checking is a method for verifying if a system satisfies a set of properties, and is used to aid the debugging and validation of software models. For example, given a description of a traffic light control system, it could verify that both pairs of lights will never be simultaneously green. The description of the system is the model, and the impossibility of all lights being green is the property. Model checking typically accomplishes this by viewing the input model and properties as logical formulations, and checking them against each other.
TCMC (Transitive Closure Model Checking) is a model checking technique and uses first-order-logic to view a system as a set of states, and transitions connecting them (a transition system). Alloy is a software that can generate counterexamples to failing properties on a model, and TCMC is implemented in its analyzer. However, because of the transition system view of TCMC, the counterexample generated is also a transition system, instead of the specific path of states leading to the property violation. It will tell you that it is possible for all lights to be simultaneously green, but not the exact sequence of events causing it. Our contribution is to isolate the counterexample path by adding logical constraints. This solution does not require any extensions to Alloy. We demonstrate our technique in Alloy and compare its performance to TCMC. Model checking is a method for verifying if a system satifies a set of properties. This is useful in debugging and validating the behaviour models of software systems in software development process. In model checking, a logic property is verified against a formal model of a transition system. If the property fails, a counterexample path is returned, which shows the path that does not satisfy the property. In particular, we addresses the problem of how to extract counterexample paths for the transitive-closure-based model checking (TCMC) technique.
TCMC is an encoding of computation tree logic with fairness constraints (CTLFC), which describes a property of the behaviour of a transition system from a particular state, in first-order logic with transitive closure and has been implemented in an open source analyzer named Alloy Analyzer. Since TCMC is defined over transition systems and states, it returns a transition system with a bug as a counterexample. However, this becomes cumbersome for modellers if the transition system is complicated or the size of the counterexample is substantial. Our contribution is the isolation of a counterexample path or the smallest subgraph in some cases from the transition system counterexample in a declarative manner by adding constraints.
CTLFC uses a combination of temporal operators such as X(next); and path quantifiers such as A(all paths) Model checking is a method for verifying if a system satisfies a set of properties. In particular, our project addresses the problem of how to extract counterexample paths for the transitive-closure-based model checking (TCMC) technique. TCMC is a representation of CTLFC, which is explained next, model checking problem First of all, computation tree logic with fairness constraints (CTLFC), which uses a combination of temporal operators and path quantifiers to describe a property of the behaviour of a transition system from a particular state. TCMC is a representation of the CTLFC model checking problem in first order logic with transitive closure and has been implemented in the Alloy Analyzer, an open source analyzer used for software modelling. This technique is a non-iterative and symbolic model checking method. It is defined over transition systems and states (rather than paths) and therefore, returns a transition system with a bug as a counterexample. However, this becomes cumbersome for modeller if the transition system is complicated or the size of the transition system is large. Our contribution is to isolate a counterexample path in a declarative manner by adding constraints. Our method does not require extensions to Alloy. We demonstrate our method and compare its performance to TCMC.
Data Review Tool : Runway
Matthew Acton, Suleman Azam, Wasim Kapadia and Arun Ranganathan
Justin Stribling, Robert Lai, Wendy Fu, Calvin Chan, Jacky Han
Every year, engineers at Aviya, an aerospace systems company, spend hundreds of hours analyzing simulated aerospace engine output for correctness. Our project is to automate some of this process and reduce the effort spent that could be used elsewhere for more productive work. Much of the current process is tedious. The addition of our tools into Aviya’s existing workflows will allow greater utilization of their engineering time.
We are using artificial intelligence techniques, such as machine learning, in order to detect anomalies, forecast predicted correctness and make comparisons. A key design challenge is tweaking the machine learning algorithms to use optimized parameters and updating these values over time as we get feedback on our results. This design requires technical knowledge in artificial intelligence and data analysis.
The existing alternative involves hundreds of hours spent analyzing output, so the main advantage of our design is the time that can be saved by automating parts of the process. Another advantage will be the reduction of repetitive tasks performed by the engineers at Aviya allowing them to spend more time focusing on other tasks.
Project G : Glue
Peter Lakner, Olivia Cao, Casey McLewin
Swift is a programming language that is picking up lots of traction lately with its involvement in iOS. But that isn’t the only thing that it can be used for. Due to its open source nature, many people are pushing it and having it work on Linux, which isn’t what Apple usually likes to do with its products. Swift is a powerful scripting like language that also gives its devs the power of low level functionality. We are also in a time where ML is gaining significant traction and the tools that we have at our disposal allows for pretty much anyone to apply ML to their products or apps.
Open source projecfs are cool because they tend to reach a lot of users and help with the growth of computer science as a whole. Contributing to a large open source project that’s only at its infant stages due to the language it is adopting also being in its early stages, is such a cool opportunity since we are learning about things “at the beginning”.
ML and compilers are not something simple that anyone can just hop into willy nilly. That’s why specialzed people design tools to make it easier. However, a large part of Tensor Flow is its accelerator framework that normally just provides wrappers to other languages, but the power of Swift allows for there to be an actual compiler for the Swift version of the tool and have users develop with design patterns they’re used to and leverage the great features that come with Swift.
There hasn’t been any public deployment during the last work term since this required a lot of research and testing before we push our code and have it be reviewed by the Tensor Flow commitee.
Sandboxing for Algorithmic Trading : AlgoWiz
Josh Carnide, Jean-François Bisson, Keith Carscadden, Jeff Hudson, Bryan Lo
Algorithmic trading is a method of trading where a computer program uses a set of rules (trading strategy) to automatically perform trades on an exchange. This method is used in institutional settings as well as individual settings where it serves as an attractive field and hobby for programmers. Our project is a domain-specific language designed for algorithmic trading with performance, ease of use, and security in mind.
The problem at hand is how to execute user-written code while offering performance and security. A common solution to this problem is containerization. However, the time cost of starting and managing containers makes it unsuitable for trading applications. The memory footprint of containers also limits the amount of “sandboxes” one can have on a given machine. This project will explore a domain-specific language based solution.
Improving the Canadian walk-in clinic experience
Jitin Dodd, Charles Bai, Yash Goel, Meet Bhavsar, Zaid Shennar
There are roughly 2500 walk-in clinics in Canada. Unfortunately, the waiting experience at walk in clinics have not caught up to today’s modern Internet standards. Information regarding waiting times have only recently been accesibile via the web. In order to check your position in-line, you must be physically in the waiting room talking to a receptionist – and the reported wait time depends on the receptionist’s judgement.
People are time-sensitive. Users want to know how long a wait will be at each clinic before committing their name down, and expect it to be reported accurately. Furthermore, waiting idly in the waiting room is not an efficient use of time. Users would prefer to make use of that down-time, and having an accurate representation of the current waitlist’s progress at-hand will be extremley useful.
Utilizing a mobile app, information will be presented on-demand at the user’s convenience. Utilizing smart algorithms, the wait times reported will be based on data points collected in reality.
Medical Protocol Syncing Mechanism : Sana
Felix Lam, Justin Kim, Michael Socha
The World Health Organization (WHO) estimates that around half of the world’s population has poor access to essential healthcare services. Most of this population is in the developing world, and a common obstacle to delivering healthcare lies in distribution to remote areas. The effects of improved healthcare access are far-reaching, and include increased life expectancy, reduced poverty, increased workforce participation, and an overall improvement in quality of life.
Sana is an MIT-based organization that focuses on improving healthcare access in developing parts of the world. A core part of Sana’s solution lies in its mobile health (mHealth) app Sana Mobile, which allows remote healthcare workers to collect patient data and relay it to clinicians. Remote healthcare workers upload this data by filling out custom input forms built from underlying protocols. These protocols are defined in XML, making them tedious to edit without a dedicated tool. Previous FYDP groups have implemented a web-based tool for building these protocols.
However, the Sana Protocol Builder and Sana Mobile remain largely unintegrated. The most common technique for adding protocols to Sana Mobile deployments is manually through the app’s APK, which is tedious and does not keep protocols on mobile up-to-date with changes on the Protocol Builder. The goal of this project is to connect the Protocol Builder with Sana Mobile using Sana’s Medical Data Store (MDS) as an intermediary. Protocol Builder users can push protocols to an MDS instance, where they can be organized into protocol groups that are periodically pulled by Sana Mobile. In addition, we are extending the protocol definition language to support further UI customization of input forms, such as interface skinning.
Development of this new functionality to Sana Mobile, the MDS, and the Protocol Builder was carried out in 2018 and early 2019 in close collaboration with Sana’s leadership. We aim to have these new features rolled out in February 2019 as part of a major release. This release will be used in Sana’s existing deployments in Lebanon and sub-Saharan Africa.
David Zhang, David Qian
Baseball games take an average of about 3 hours, and with up to 15 MLB games playing at once, it can be hard to keep up with multiple players while juggling a busy schedule.
With Batter Up, it is now easier for people to keep up with their favourite players and get more enjoyment from the MLB season.
Batter Up empowers users by monitoring the state of all active baseball games, and then sending the user a notification to tell them that a player they are following is about to bat or pitch. The user can then switch over to the game so that they can watch the player’s at bat. The app itself will be a chrome extension.
The main advantage of Batter Up is that it fills a need that is not addressed by any other solution. Currently an user would have to actively monitor the boxscores of every game. With Batter Up, the user would be free of this burden and focus on whatever they’re doing.
We expect Batter Up to be installed by a number of users that regularly engages with the app and notifications, which would indicate that we are fulfilling a need in their baseball watching routines.
Benjamin Wang, Howard McLauchlan, Szilard Balla
Esports is an industry undergoing extraordinary growth as the proliferation of computers makes gaming increasingly popular amongst today’s youth. As the scene matures, significant efforts are being made to foster a competitive atmosphere at lower levels of play. While the advent of services like Discord has proven useful for organizational efforts, the lack of an integrated solution for tournament administration remains a pain point for many parties.
Our objective is to make a tournament matching system that reduces the work on administrators by automating creation, pairings and the recording of results through Discord commands that participants can use themselves.
Since the esports scene has grown so rapidly in recent years, there are few incumbent players in the space. Discord is a dominant force in the market, but its core competency is being the place for gaming communities to chat. They expose a feature rich API which enables us to leverage their market dominance by integrating directly into Discord channels.
The back-end of our application handles the matching algorithms that go into generating a custom tournament bracket. Our goal in this area is to offer several different algorithms that align with different types of games and tournaments.
We also have an appealing integration with Discord so that people who talk in one channel can easily set up a tournament bracket if they want to play right away. This implies that we must communicate with the Discord API in an efficient manner.
We will make a system that can generate tournament brackets in various formats. We will have Discord integration functioning, so you can control the tournament bracket from commands from Discord. Furthermore, participants themselves will update their own scores in order to reduce administration overhead. The system also will automatically flag cases where two players update the same score with a different result, which should prevent any abuse cases from happening.
Hive: An app for connecting peer mentors : SyncUp
Adam Klen, Steven Kong, Andrew Codispoti, Wojtek Swiderski
Many students struggle making the transition from high school to University. For a sizeable portion of students, there is a lack of social support; students are taken away from their support system – their families and existing friend networks – and are placed in an unfamiliar environment where the challenges they face are arguably more difficult than any they have experienced in the past. The pressure of stepping up to try and overcome these challenges forces students to adapt quickly.
Mentorship is a great way to transfer knowledge and wisdom. The co-op program at the University of Waterloo believes so strongly in the power of mentorship that they mandate each company to provide a student with a mentor to guide them through the challenges of the workplace, technical and otherwise. Incoming students can benefit from having similar support: Hive provides students with a mentor. Hive’s primary mission is to create relationships that help students navigate their university experience.
The University of Waterloo hosts a talented and diverse group of students. Though, it is often the case that students silo themselves into cliques exclusive to their programs and cohorts. Hive helps bridge the gaps between the various disciplines and helps students expand their networks. A big part of Hive’s mission is to build stronger relationships, not only between cohorts, but also programs. Through strengthening the networks that already exists at the university, we aim to empower a student to grow a more diverse network.
After having talked to early users through interviews, we have very promising results about the overall positive reaction towards the community we’ve created. Through partnering with many existing mentorship initiatives, at the time of this writing we have more than 600 users signed up on our platform, creating almost 500 connections. After conducting surveys, we have determined that most first year users met up with their mentor at least once. Our ongoing goal is that all users are able to make at least one strong connection that they otherwise would not have the chance of making.
Graduation Verification & Planner : DegreeCompass
GuangZhi Xiao, Jack Zhou, Ken Torii, Calvin Hua, Ian Zhang
Computer Science students at University of Waterloo currently deal with complicated graduation requirements such as “3 courses having the same subject forming a prerequisite chain of length three”.
Our project goal is to make these students’ lives easier by creating a webservice that faculty and students can use to determine graduation eligibility.
Current objective is to let student user upload a transcript to our web service and be told whether graduation is possible or not. For department admins, let them specify a new program’s requirements using DSL which our app can parse.
Currently, our app model has 3 main components: Satisfaction, CourseRequirement, and ContainerRequirement.
CourseRequirements consists of the following children classes: AllOf, SomeOf, OneOf. You use this by initializing a children class with: a list of required courses (ECE124, SE350), a required faculty (CS*), or a required faculty plus a course number range (PHIL200+). We intend to model each degree requirement to one of these class objects (like the CS prereq chain of 3).
ContainerRequirement consists of the following children classes: AndContainer, OrContainer, XorContainer. These containers can contain a list of other container classes or requirement classes.
After the entire degree requirements are prepared, our solver then tries to fulfill requirements with a different course at each stage of the solving process and does this for all remaining requirements and unused courses. In essence, we try out each possible combination of courses with requirements and take one with the most requirements fulfilled.
Preliminary testing indicates that our app can figure out whether the student can graduate within seconds. This is a vast improvement compared to manually checking the requirements’ fulfillment.
RezQ.io – Resume Critiques : RezQ
Ian Yuan, Evan Cao, Gary Zheng, Andrew Gapic, Judy Chen, Fanny Deng
Over 19,800 undergraduate students are enrolled in a co-op program at UW each year. Students often face difficulties obtaining feedback for their resumes. In the most recent “Resume Critique Megathread” on the UW subreddit, there were over 200 comments within 8 hours. Evidently, there is a large demand for resume critiques from co-op students. We will fill this demand by offering a peer-to-peer resume critiquing platform open to anyone for use.
RezQ offers several unique features including industry-specific critique matching, sharable resume critiquing links (similar to Google doc sharing), and a public pool of resumes which anyone can review at any time.
The key challenges we face include securing user information, providing a good UI/UX, and designing a scalable and reliable service. Naturally, RezQ stores a lot of personally identifiable information. In order to protect user information, we have applied various security concepts to ensure our platform is secure. Next is UI/UX design: while we are not professional designers, we aim to continuously improve RezQ by iterating on user feedback. Finally, our platform applies ideas and concepts from previous courses in software architecture and distributed systems so that it is both scalable and reliable.
One clear advantage that our platform offers over other solutions such as a Reddit thread is that our platform offers annotations. This allows critiquers to write directly on top of a user’s resume. Our philosophy is that a picture is worth a thousand words.
We recently launched a public beta for our platform and have received almost 75 signups on the first day. There were 25 resumes uploaded, 15 critique requests, 25 requests to critique, and 10 sharable critique links created. Our Reddit post has over 50 upvotes, suggesting that users are happy with the product idea. We even had one user from Carleton University.
Resume ranking for focused recruiting : Team u2careers
Lingyun Guo, Jingyang Gary Zhang, Minyang Jiang, Jiale Sun
Everyday, millions of resumes are submitted by job seekers to recruiters, in hope of getting the recruiter’s attention and being considered for a follow-up interview. Needless to say, resume screening is one of the most critical steps in the application process, as a turned down resume most definitely means that the application is hitting a dead end. In fact, talent acquisition leaders generally agree that screening resumes is the hardest part of recruitment.
However, the resume screening process often does not receive as much standardization and justification as it should. Nowadays, many companies make use of an ATS (Application Tracking System) or search engines to aid the screening process. Nevertheless, most of the resumes are reviewed by real people and bigger companies even have specific roles to screen resumes. Due to the large influx of resumes to the recruiters, each resume usually gets less amount of inspection than it deserves; most resumes are just glanced over by a single recruiting specialist / team member, possibly with important details left unnoticed. In addition, the accuracy of the judgement can swing depending on the recruiting person’s mood, expertise and experience.
U2careers is capable of inspecting the applicant pool thoroughly and consistently in the blink of an eye. Given the list of job requirements, it produces a score for each resume, which can be used to filter out a large majority of applicants that do not meet the bar. It is estimated that usually up to 88% of received resumes are unqualified for an open job position. U2careers helps identify the 12% that meet the requirements, while providing insights on why others failed to make it under the spotlight. Users have reported that all the resumes that meet the minimum qualifications are in the top nth percentile of the score range, meaning that recruiters generally only need to look at n% of the resumes, saving a considerable amount of time spent on manual screening.
The system could be extended to a broader range of applications. As part of the project, we have built a platform that connects job seekers with internal referrers using the matching scores. This gives the qualifying job seekers a better chance of getting an interview opportunity by utilizing referral programs run by many companies. As another example, our resume scoring system can be integrated into a resume critique application to give valuable suggestions on how to target your resume towards certain categories of job positions.
uwJAMS : Fergus
Wenting Hu, Tyler Boyd, Robbin Xu, Cynthia Liu
Students at the University of Waterloo are very focused on the job search with 19,800 students enrolled in co-op programs every year. The job search can be highly stressful as students spend a lot of time finding positions to apply to and keeping track of the status of their job applications. Each term, students make up to a hundred job applications with no easy way to track the status and tasks involved in all of their applications.
uwJAMS is a centralized place for students to track and manage their job applications so that it is the one place they go to during their job search process. This is achieved by creating a system where UW students can import their job applications from WaterlooWorks through a simple copy-and-paste mechanism and add external job applications manually. Through this application, students will have the ability to update and track the status of all of their applications, record interview dates and times, and document any other useful information such as employer contact information. This product facilitates the job search process, allowing students to focus more of their time and effort into more productive tasks such as interview preparation.
Unlike many other job tracking tools, uwJAMS is catered specifically to UW co-op students. The only existing UW-student focused tool, WaterlooWorks, does not allow for any customizability as students are unable to add external job applications to the system, which is an increasingly common occurrence. In addition, job statuses on WaterlooWorks are oftentimes inaccurate and interview schedules on WaterlooWorks are incomprehensive as the recruiting process for many employers happens behind the scenes. Therefore, uwJAMS does not intend to compete with WaterlooWorks, but acts as an extension to provide a centralized and fully customizable system, solving all of the aforementioned problems.
To demonstrate the effectiveness of our product, we will record user-based data to collect statistics such as user retention rate over the job search period per term. A consistent user base implies that our tool is superior to its alternatives, and thus more effective in facilitating one’s job search process.
Student communication app for PsyKick
Yassin Zaoui, Tianxiang Liu, Wen Shi
PsyKick is a company that provides tutoring services. To attract more students, it should be easy for students to find courses that they are interested in. Once they find the courses, it should be easy for them to sign up for the course. To be more student- friendly, it should also be possible to easily track students’ progress. To increase students’ engagement, students should be able to provide feedback to teachers and leave comments about a teacher or a course so that future students can easily select the right course to take.
Students and teachers currently do not have a direct way to interact with the company. All communication is made through instant messages through third party apps or through emails. This introduce significant delay in getting any information about the company or the courses that it offers. Our app addresses this issue by centralizing all information about the company and the courses it offers into one place.
Our mobile app uses the latest cross-platform mobile app SDK, flutter. Majority of the project is written in Dart 2.0, a type-sound language. The project also uses AWS to host its back-end services. This include REST APIs, relational databases, user registration and authentication, and data storages.
Mobile strategy game : Adrestia
Dmitri Sclear, Charles Zinn, Jim Zhang
Real-time strategy games like StarCraft are rewarding to play, but require significant time commitment. Mobile games are accessible, but lack strategic depth.
Adrestia is a mobile strategy game that we designed in response to these shortcomings. Unlike a real-time strategy game, it is easy to pick up and fast to play, but unlike a mobile game, it has significant strategic depth. We designed Adrestia in such a way that interesting strategy arises naturally from simple mechanics.
Our game mechanics are also amenable to AI players. We implemented an AI using counterfactual regret minimization and machine learning, and we use this AI both as an opponent for offline play, and for testing the game to ensure that there is no single dominant strategy. Implementing an AI for a real-time strategy game that could be used in such a way would be much more difficult, since the search space is intractable; most AIs for such games simply execute known strategies and cannot be used to test for balance.
We hope that Adrestia will combine the intellectual stimulation of StarCraft with the accessibility of Candy Crush.
Foodie : JAY
Jack Wang, Yemin Shou, Austin Du
Foodie is mobile app that provides a unified crowd-sourced directory of restaurants and their menu items, aiming to provide quality images and information for every menu item in any given restaurant as well as contextual information about the restaurant itself. A flexible search feature allows for querying by specific dishes or cuisines across all restaurants in the area, with an authentic and comprehensive image-based feed of results. This product aims to be the de facto directory for all restaurant menu items.
Currently, many consumer dining applications depend largely on personal reviews – where the overall rating of a restaurant can often be skewed as customers who have had a bad experience are much more likely to leave a review than customers who have had a good experience. We also find reviews may be skewed positive by restaurants giving away discounts or free items to review. Our product explicitly does not support reviews of the restaurant or its dishes – it allows the photos of the dishes to speak for itself.
Foodie is meant to be a visual dictionary of restaurants. By acting as a non-review-based channel for sharing restaurant information, we hope to garner more support from restaurants than existing alternatives.
Starting in a relatively small area, this product first concentrates in the Waterloo region before expanding. A large challenge for this project is the problem of data acquisition – receiving enough information and photos about restaurants to be considered useful by users. To incentivize the population of data, the app offers rewards to users based on how much they contribute to the directory of restaurants – either through providing photos of menu items or providing the menus themselves.