Today we're excited to post a Play Framework story with Ben McCann, an active community contributor and co-founder of Connectifier, where Play retains a long-term, mission critical role at this leading big data and AI company. In this story, Ben discusses the recent Play 2.4 release and how the open source nature of Play Framework has benefitted Connectifier.
I got hooked on programming when I created a guitar website in high school that grew to over a million hits a month. So I studied Computer Science at Carnegie Mellon and ended up getting my MBA in the four years that I was there because I knew I wanted to start a company one day. I worked at Google for a few years where I built some of the core UI in Google Spreadsheets like the formula bar and formula highlighting and helped launch Realtime Analytics, which measures about half the world’s internet traffic in real-time. I then went on to found Connectifier with John Jersin, whom I met at Google.
Connectifier makes talent search engine technology that helps recruiters discover, qualify, and connect with exceptional job candidates with roughly twice the efficiency of existing methods. We’d love to provide a list of perfect matches from just a job description or resume without making you even enter a query. Because that problem is so challenging and fun to work on and we have some great recruiting tech, Connectifier has been able to attract a great team from places like Google, Amazon, Microsoft Research, Stanford, Carnegie Mellon, NASA, and Berkeley National Lab. The product is already used by thousands of agencies, startups, and more than 40% of the Fortune 100.
Nearly all of Connectifier’s infrastructure runs on Play. We decided to build on the JVM because of the ecosystem (Weka, Hadoop, Spark, etc.) and because our early team was all from Google and knew Java so we could hit the ground running.
Most of Connectifier’s infrastructure runs on Play. Play powers our user-facing website, admin functionality, batch job interface, etc. We investigated numerous web platforms at the beginning of 2012 before Play 2 had been released and saw there was some really exciting stuff happening with it. We decided to build on the JVM because of the ecosystem (Weka, Hadoop, Spark, etc.) and because our early team was all from Google and knew Java so we could hit the ground running. We also thought it was important for Connectifier’s infrastructure to be supported by a commercial entity, in this case Typesafe. When there’s a full-time team working on the software you depend on, it tends to be much better supported than when it’s someone’s hobby project.
One of the things that I’m excited about in Play 2.4 is the support for embeddable applications. This means that we can take jobs that aren’t traditionally web applications and embed web servers in them to expose health checks and application metrics over HTTP. Connectifier already has infrastructure built up to consume metrics, such as those exported by Dropwizard Metrics over HTTP, so being able to expose all that using embeddable applications in Play will be really useful for us.
It was a requirement for us that we build on open source infrastructure. We push a lot of our technology to its limits and we want to be able to peer under the covers and see what’s going on. Play being open source means that whenever we see an opportunity to make things easier for our use case, we can submit that upstream. With a closed-source product we’d have huge layers of ugly workarounds and problems that we could probably never solve.
It was a requirement for Connectifier that we build on open source infrastructure. We push a lot of our technology to its limits and we want to be able to peer under the covers and see what’s going on. We’ve even submitted pull requests to our web browsers and database to make Connectifier better for our users. Play being open source means that whenever we see an opportunity to make things easier for our use case, we can submit that upstream.
With a closed-source product we’d have huge layers of ugly workarounds and problems that we could probably never solve. The Connectifier team is growing quickly and for each new person we add they’ll hit all the problems the rest of us have hit in the past if not solved. Utilizing open source projects means we can solve those issues so that they never hit them and the team moves more quickly as a result.
One of the projects I’ve personally contributed to a lot recently is sbteclipse. I ported Play’s Eclipse code upstream to sbteclipse so that other SBT users could benefit and so that it could have a release cycle independent of Play’s. We care a lot about making Connectifier a good place to work and I feel like part of that is working out all the little kinks that can get in a developer’s way so that we have a really smooth development cycle and can just focus on the important stuff. Play 2.4 makes using Play with Eclipse even smoother than it’s been in the past.
We’re actually so confident in Play’s testing that Connectifier has been running RCs in production for the past few weeks so that we can take advantage of some of the new features sooner.
We just talked about the open-source nature of Play, which has been huge for us at Connectifier. Especially because it’s steered by a very strong team that’s worked with us to take our feedback and pull requests into consideration. It’s always a tough balance to work with the community and review all code submissions in a way that you’re not taking everything and the project becomes everything but the kitchen sink or unstable. The Play team has managed very well to be open to contributors and review their work carefully. It’s not just where Play is now, but the trajectory we’ve seen it take over the past couple years. Each release has gotten consistently better. We’re actually so confident in Play’s testing that Connectifier has been running RCs in production for the past few weeks so that we can take advantage of some of the new features sooner.
Also, I mentioned the JVM ecosystem earlier that Connectifier benefits from. Play builds on this ecosystem in a very clean way that many of the other JVM web frameworks we looked at don’t. We didn’t want to deal with loads of XML, or Java EE, or any of the cruft that folks complain about when they hear Java and think of some outdated enterprise shop.
With Connectifier’s early team being from Google, we enjoyed using Guice and wanted to have the ability to do dependency injection without XML. Play’s had good support for this which is getting much stronger in Play 2.4. As a startup, things move very quickly at Connectifier. We’ve built features for customers in a day numerous times. Our tech stack has to accommodate that. I love that Play has embraced Java 8. It’s really nice to be able to take advantage of the latest features once they’re stable.