My news feeds are different. Suddenly I find them full of hackathon hype and posts about the tech startup industry. It wasn’t always like that; just six months ago I only personally was friends with a handful of other software engineers, and we didn’t even interact that much.
Fast forward to today, and I’m making connections with really accomplished developers from all over the US on a weekly basis. And I’m working and building useful things with them all the time. Now there’s this community of really talented people with more awesome ideas than I possibly have time to collaborate with. Everyone’s friending and following each other. It’s great.
I imagine all the ‘normal’ people on my friends list are probably just really confused.
How did I get wrapped up in this? I started going to hackathons every weekend, and I got involved with others who want to create a hackathon for my school, Maryland University (bitca.mp). Hopefully the constant first-hand hacker experience will make me better at doing my job as an organizer.
Now I just need to sponsor a hackathon; I’d have all three bases covered.
Why is this happening now?
Everyone wants to throw a hackathon. Probably because they’re basically big parties. 93% of the reason I attend hackathons is simply for the fun of it. All your friends are there, food and caffeine are paid for, you get a (usually) free mini-vacation, and most importantly, everyone there is doing what you love – making stuff. And everyone wants to team up and collaborate on that simple concept.
That’s the value of hackathons over career fairs. At a career fair, I hand in my resume and try to schmooze some recruiter. At hackathons, I work with my peers, hacker mentors, and developer evangelists from amazing sponsoring companies, and I make useful things. One of these is clearly better than the other. In fact, since hackathons became a thing, I’ve actually stopped giving out resumes entirely; I only show people my work now, with generally positive results.
Where is this happening?
Largely at universities in the US, and mostly on the East coast. But the number of collegiate hackathons on the West coast is steadily growing. During the fall 2013 semester, there were perhaps a dozen hackathons of significant size. There were probably around a half dozen really big ones (~700+ hackers).
This semester, there are more new first-time hackathons than there are sequel hackathons. During the weekend of my own event, Bitcamp, there are at least five other large hacker events on the east coast. As you can imagine this is actually a problem for some. For instance, convincing hackers to drive past HackNY and come down to the DC area for Bitcamp is definitely a daunting challenge.
But I’m not complaining! This is a good problem to have. It’s now entirely and easily possible to attend a hackathon every weekend now. My average this year is a bit above 1/week. The overcrowding of hackathon events is a potential problem in the future, but a solvable one.
So what happens at hackathons?
All sorts of things! Hackathons aren’t just programming competitions – they’re about creatives inventing with technology.
One of my favorite and most recent projects was something I built with a Leap Motion Controller at PennApps Spring 2014. Leap Motion’s developer evangelists lent my team a few controllers, which made the whole thing possible, and they actually let us keep them in the end. (Thank you!)
My team wanted to bring the nostalgia of the ’90s to life. Many people who grew up during that time will remember a toy called Bop It, by Hasbro. My team and I recreated the fun and experience of Bop It on your computer almost to a T, using Leap Motion technology. You can actually see and use it for yourself right now, at bopit.io. Plug in your Leap Motion Controller, or use the simple keyboard controls.
Building Bop It on the web
The team consisted of Jeff Hilnbrand, UI designer (and founder of gethotdrop.com), Luis Santos and Mariel Bartolome, both frontend developers, and of course myself. Jeff had the idea, and made mockups and art assets. I designed and the engineered the project as a whole, and implemented the back end and much of the front end. Luis connected the webapp to a Hue light and programmed the gameplay animations. Mariel programmed the Leap Motion Controller gestures and also implemented a few other frontend features.
The gameplay of Bop It itself is very straightforward. Follow the commands to the rhythm as the game instructs them. It gets faster and harder as you play. It also has multiplayer support; the game pauses for a measure and says “Pass it!”
The gameplay of bopit.io is exactly the same. Actually implementing this gameplay proved rather difficult, mainly because we wanted bopit.io to be accessible to the largest possible audience, and so chose to make a web app. To support the multiplayer aspect, I had a Node.js server communicate with clients via websockets.
The game mechanics of Bop It are based on timers, however I didn’t actually use any timers in bopit.io’s frontend. Instead, I told the Node.js server to send a random Bop It command (bop, twist, pull) at a set interval. On the frontend, I took those commands and represented them as a linked list of BuzzJS soundbites that Jeff measured and clipped from YouTube videos of Bop It.
The soundbites are linked into a list, not by references to other soundbites, but by callbacks – every sound has a reference to the next sound/command that should be played. On the Node.js server, I just makes sure to spit out new commands before the frontend’s list plays its last sound. Essentially the game is a infinite stream of sounds/commands.
Designing it this way was quite strange, because while the gameplay is entirely based on timers, I didn’t actually ever set any timers. We just made sure to slice up the soundbites into proper fractions of the whole game, and continually played them one after another. The benefit to this design decision is that any client can join the game at any time.
Essentially, bopit.io is massively multiplayer, because the frontend code just hooks into this stream of sounds from the Node.js server and ends up being (somewhat) synchronized with everyone else.
The LeapJS library was a pleasure to work with! It adds a whole new element to any type of computer-human interaction, especially in the case of games like Bop It. It was a really a great experience, so I now have quite a few more plans for things that I’d like to make with Leap Motion Controllers; you’ll see them in the Airspace Store soon!