Inspiration

As college students, we often find ourselves looking for our next cheap, lazy meal but struggle to come to an agreement on what would properly satiate our hunger while maintaining a balance budget. Not to mention, we never really want to travel far from our area, because you have to factor in gas prices or delivery service fees. Our group of four friends found ourselves on a road trip through the lower states, naming off food places we found on road signs as we traveled along the interstate. By the time each exit rolled around, we couldn't decide if the options were getting less appealing, or if we had been driving too long to come to a proper conclusion. It was there that the idea for Let's Eat was born-- an app that we could swipe through local restaurants and come to a virtual agreement via an algorithm that would feed suggestions based on location, price, and user rating. We could also come across restaurants we didn't know about, aside from the likes of McDonald's, Wendy's, or Burger King. Further still, the main focus of the app would rely on a constant feed to continuously show various eateries until we found something that we liked.

What it does

Let's Eat mobile app delivers a continuous feed of data from restaurants styled as individual cards on the main screen. The feed of restaurants is gathered from a prominence ranking, which takes into account hours, location, price, and user reviews from google-places API. The primary user creates a group with another user, and they are separately fed the same feed of restaurants based on their two locations. Then, the users either decide yay or nay if they are interested in eating at that restaurant. If the two users come to a consensus (choosing yay on the same restaurant), then it's a match! Information about the restaurant is shown to the users, including the address, so they can begin their snack-time process!

How we built it

Using the iOS development framework SwiftUI, we developed a frontend to integrate user access with the prominence ranking data. Google's Firestore database houses much of our data including users, groups, and more. Moreover, Google-places API funded the data for the restaurants including their location and name. Finally, through Google-Cloud functions we can tie the front end through HTTP requests to the backend on Google-Cloud and finally query the database for information. All of Google's software handling was managed through processes written in Golang, which is a statically typed, compiled programming language developed at Google.

Challenges we ran into

Firestore Golang Documentation

We were having difficulty using Firestore queries to return a populated interface of typed values instead of empty interfaces. Due to time constraints and an internal bug, we were forced to use a buffer hack to check for matches in groups.

Web-App

Initially, our plan was to simultaneously build a web-app to match the mobile interface using ReactJS. After hours of troubleshooting, we could not figure out a workaround for Cross-Origin-Resource-Sharing (CORS), which would be a breach in online security. We continued to develop the web-app front end, but not to the same extent as the mobile version.

Large Group Scaling

The biggest challenge we faced, one that put us the furthest from the image of the finished product in our heads, was our struggle integrating large group support into Let's Eat within 36 hours. For demonstration purposes, we limited the group size to 2 users.

Learning New Technologies as We Go

With only a day or two of reading SwiftUI documentation under our belts, we weren't exactly masters of mobile development. Likewise, we were not well-versed in Google-Cloud functions nor Firestore. Furthermore, this was our first time writing any application development that wasn't a local project. We had to learn each new piece as it was needed for the project.

Accomplishments that we're proud of

In short, we are really proud of every detail in Let's Eat. This is the first time we have seen an idea come to fruition remotely close to how we had imagined it. To start off as a joke among friends on a long car ride, and end up as an app with a promising future, is an amazing feeling. We will continue to keep our heads in the dirt and put our newly learned skills to the test to further develop Let's Eat. Aside from a few days of SwiftUI and Go documentation scrubbing, we are proud of the fact that we learned and deployed skills within a few hours: technical abilities that we can take with us to a professional level.

What we learned

Going into this project, we knew a few things. We needed to invest time into learning mobile development, like using SwiftUI, because mobile outreach has the easiest access for consumers. After that, came the discovery for the need of a database, for which we went with Google's Firestore. Furthermore, we had no collection of data, but google-places API sure did. Finally, we needed to host our functions on Google-Cloud. To be profficient in all of these tools was essential, especially because we needed these tools to communicate back and forth with one another to develop a continuous stream of restaurants for the user.

What's next for Let's Eat

The possibilities are endless for Let's Eat, and we have many ideas to turn this application into a mainstream product for consumers.

Group Scaling

We will add larger group scaling support to seamlessly connect together and find the best place to eat! As of now, there is limited functionality with large groups, so we need to develop the database queries to handle large groups.

More Info on Restaurants

In our limited time, we scraped the name, address, phone number, image link, hours, price, and rating and review numbers from google-places API. However, we had yet to process and display beyond the name and address at the time of submission, but is is definitely our first priority in development to display data that helps the user reach the restaurant faster.

UI Improvements

Our main focus was to connect a functional front end with a functional backend that carries out our vision. In doing so, our priorities were located on connecting our database, Firestore, to our Google-Cloud functions, and finally landing them on the frontend. That being said, our visual were planned out far beyond our physical implementation. Card animations, image data, swipe animations (instead of buttons), better text-boxes, higher res assets, a main menu, UI support for Oauth (more on that later), can all be added to improve the UI.

General Code Cleanups

Look, it's a hackathon. I wouldn't say that the code is wrapped neatly with a bow.

User Data Analysis, Profile System, and Oauth

The biggest opportunity for expansion of Let's Eat comes with profiles for users. With profiles and Oauth setup, we will be able to use an AI Based Recommendation Algorithm (below) to push users restaurants that they enjoy often, based on cuisine type, frequently visited, or suggestions from other users. Profile integration would also flow nicely with the aforementioned Group Scaling, which would for the eventual expansion of "friends", for quick, easy groups and a fun social media aspect.

AI Based Recommendation Algorithm

Ultimately, our vision for the algorithm would be group specific, factoring in each user's likes and dislikes from their respective profiles. That way each Let's Eat experience is taylored specific to each group, allowing for a more personalized experience, which is likely to find more matches.