## Inspiration

As college students, we know that internships are extremely valuable as it provides us with the opportunity to take the theoretical knowledge we gain in class and apply it to the real world. However, the process of finding internships is slightly flawed. The career fair allows for quality in-person interactions between students and recruiters, but we have found that there are certain opportunities we can capitalize on. On the student end, we found that students often have to wait in hour long lines to meet with just a few recruiters on the off chance that they can fit the career fair into their busy schedule. On the other hand, recruiters have to pay exorbitant fees to attend career fairs, and it can be very expensive when you take into account registration fees, traveling, room and board, and so on.

## What It Currently Does

NXTPitch allows for students to upload short elevator pitches similar to the ones they use at career fairs when meeting recruiters. Students can then upload supplemental videos, links to important social media such as LinkedIn, Github, etc, and have the opportunity to set 4 skills. Recruiters can then look through a feed of these videos; if they find an individual who fits their skill-set, they can look at the rest of their profile, chat with them and even schedule an interview. Furthermore, recruiters can also search for certain skills that they are looking for in a candidate; the system will then look for individuals that have those skills listed in their profile and display them to the recruiter.

## What We Built

For Cal Hacks 2017 we decided to do a continuation project, and build an additional feature for our application. We created an AI backend, that enables students to receive automated feedback regarding the effectiveness of their videos and resumes/cover letters. Our AI backend analyzes the text and delivery of your content, and provides you with personalized analytics regarding how effective your content was. We break effectiveness down into three categories: emotional analysis, highlighted content, and professionalism and provide quantitative metrics for each of these categories using state of the art machine learning technology. We want to enable students not only to find jobs faster but also to find better jobs.

## How We Built It

We built the application using iOS Swift for the user interface, Firebase for the main database, and a Python Webserver backed by Google Cloud for the backend. We also utilized various Machine Learning API's such IBM Watson and Microsoft Azure, for facial and textual analysis. The AI backend relies on many different Machine Learning API's, Python packages, and custom functionality to enable audio extraction from video, textual extraction from PDF's, and analysis of the content. We believe that our main feature is our ability to tightly integrate all these different services into a single application that provides immediate value to our end user.

## Challenges We Ran Into

Since this was the first project we developed in iOS Swift, it provided us with various challenges as we had to get accustomed to language. In addition, implementation of the Python Webserver proved to be a challenge as it was our first time porting Python code to a server backend. Working with all the different API's was also a challenge, and ensuring the robustness of our application required many layers of error checking.

## Accomplishments That We Are Proud Of

We are proud of the Machine Learning engine that was built over the Cal Hacks weekend. It is our most sophisticated feature and we managed to get an MVP of it within 36 hours. It already has impressive functionality, and should help differentiate our product from anything else out there.

## What We Learned

We gained experience with a wide range of technologies such as iOS Swift, Firebase, Google Cloud, Azure, Flask, and so on. Additionally we gained experience in working with non-trivial API's in a demanding environment. Finally we also learned how to properly configure a backend infrastructure.

## What's next for NXTPitch

NXTPitch is currently running small beta testing at UCLA with a dozen students and a few campus recruiters. If you're interested, feel free to contact us!
## Inspiration

I really related to the problem the career councilors described. Reflecting on things can be hard. Especially when you're reflecting on yourself. Our goal is to make this process fun and easy, with a little help from our friends.

## What it does

Meerar compares HOW OFTEN you demonstrate a skill, and how much you ENJOY demonstrating it. To elaborate:

* When ever you engage in an event, Meerar will prompt you take a little note, describing your experience and how you felt.
* We then use the Lexalytics API to decide how much you enjoyed the event.
* Your reflection is posted anonymously on ExperienceMine, along with other people's reflections.
* Here's the twist: other students read your reflection and assign a "skill" that they feel you demonstrated.
* The more you review and post reflections, the more points you earn. You can earn achievements and compete with your friends like this!
* At this point, we have 2 pieces of info: how you felt about the event, and what skill you demonstrated at the event. Once you have enough data, we plot a graph that compares HOW OFTEN you demonstrate a skill, and how much you ENJOY demonstrating it, and provide an analysis on you strengths and weaknesses, and recommends events to attend to play to your strengths.

## How I built it

I built Meerar with a PHP backend, which is used to store and process user information. The front end was built on the trusty Twitter Bootstrap framework, with bunch of JavaScript libraries sprinkled in (i.e. materialize.js, chart.js). I used the Lexalytics API in order to gauge the sentiment in user's descriptions. I also wrote a little scraper to scrape from LinkedIn profiles of users which I execute with a bash script (what can I say, I'm learning). It's a bit patchwork-ish, but it works!

## Challenges I ran into

I came to McGill not knowing anyone, and being a beginner, it was challenging to find a team that would take me in. I managed to find another team of beginners but unfortunately, my team decided to leave the hackathon just after dinner was served on Saturday. As a result I had to do the project all myself: a pretty daunting task! This is my first major hackathon so I was a little bummed out. Still, I followed through because I thought I had an interesting idea. Hopefully the judges agree!

## Accomplishments that I'm proud of

I almost ran into a dead end with the LinkedIn API. Essentially, I wanted to get job information about a user from their profile. However, you needed to register your app with Linkedin and must have an official website (which I did not have) in order to qualify to recieve the access key to use their API. Since I didn't have this, I found a workaround: scrape the page manually with Python, and then exec() a bash script to scrape! Though it may not seem like much, I proud of finding the "way" with my "will".

## What I learned

Tech wise, I learned how to use chart.js. It's a really cool way to visualize data with beautiful graphs in the browser. Will definitely be using it again in the future. But what I really learned is that I have a lot left to learn. Everyone at McGill really knows there stuff. Next year, that'll be me.

## What's next for Meerar

Hopefully, if the judges like it, we can work on making it a full fledged app available online for student at McGill.
## Inspiration

During our brainstorming phase, we cycled through a lot of useful ideas that later turned out to be actual products on the market or completed projects. After four separate instances of this and hours of scouring the web, we finally found our true calling at QHacks: building a solution that determines whether an idea has already been done before.

## What It Does

Our application, called Hack2, is an intelligent search engine that uses Machine Learning to compare the user’s ideas to products that currently exist. It takes in an idea name and description, aggregates data from multiple sources, and displays a list of products with a percent similarity to the idea the user had. For ultimate ease of use, our application has both Android and web versions.

## How We Built It

We started off by creating a list of websites where we could find ideas that people have done. We came up with four sites: Product Hunt, Devpost, GitHub, and Google Play Store. We then worked on developing the Android app side of our solution, starting with mock-ups of our UI using Adobe XD. We then replicated the mock-ups in Android Studio using Kotlin and XML.

Next was the Machine Learning part of our solution. Although there exist many machine learning algorithms that can compute phrase similarity, devising an algorithm to compute document-level similarity proved much more elusive. We ended up combining Microsoft’s Text Analytics API with an algorithm known as Sentence2Vec in order to handle multiple sentences with reasonable accuracy. The weights used by the Sentence2Vec algorithm were learned by repurposing Google's word2vec ANN and applying it to a corpus containing technical terminology (see Challenges section). The final trained model was integrated into a Flask server and uploaded onto an Azure VM instance to serve as a REST endpoint for the rest of our API.

We then set out to build the web scraping functionality of our API, which would query the aforementioned sites, pull relevant information, and pass that information to the pre-trained model. Having already set up a service on Microsoft Azure, we decided to “stick with the flow” and build this architecture using Azure’s serverless compute functions.
After finishing the Android app and backend development, we decided to add a web app to make the service more accessible, made using React.

## Challenges We Ran Into

From a data perspective, one challenge was obtaining an accurate vector representation of words appearing in quasi-technical documents such as Github READMEs and Devpost abstracts. Since these terms do not appear often in everyday usage, we saw a degraded performance when initially experimenting with pretrained models. As a result, we ended up training our own word vectors on a custom corpus consisting of “hacker-friendly” vocabulary from technology sources. This word2vec matrix proved much more performant than pretrained models.

We also ran into quite a few issues getting our backend up and running, as it was our first using Microsoft Azure. Specifically, Azure functions do not currently support Python fully, meaning that we did not have the developer tools we expected to be able to leverage and could not run the web scraping scripts we had written. We also had issues with efficiency, as the Python libraries we worked with did not easily support asynchronous action. We ended up resolving this issue by refactoring our cloud compute functions with multithreaded capabilities.

## What We Learned

We learned a lot about Microsoft Azure’s Cloud Service, mobile development and web app development. We also learned a lot about brainstorming, and how a viable and creative solution could be right under our nose the entire time.
On the machine learning side, we learned about the difficulty of document similarity analysis, especially when context is important (an area of our application that could use work)

## What’s Next for Hack2

The next step would be to explore more advanced methods of measuring document similarity, especially methods that can “understand” semantic relationships between different terms in a document. Such a tool might allow for more accurate, context-sensitive searches (e.g. learning the meaning of “uber for…”). One particular area we wish to explore are LSTM Siamese Neural Networks, which “remember” previous classifications moving forward.