Over the past couple months, you’ve probably heard a thing or two about Pokemon Go. In the past 55 days, it’s gone from a pre-launch to a peak of 45 million daily active users (usually abbreviated DAU). The mobile game has now stabilized at around 30 million DAU [source].
If you haven’t played it, it’s an augmented reality game. And one of the first of its kind to gain mainstream adoption. By “augmented reality,” I mean that it uses a mobile phone’s camera and layers additional data into the real world.
Anyone who has played Pokemon Go, whether they liked the game or thought it was stupid, has probably thought:
“Holy smokes this augmented reality thing is crazy cool and has the potential for incredibly cool use cases.”
The team at Niantic (the Pokemon company), has done a ton of things right and lots of other things wrong. But as a programmer, it’s incredibly inspiring to see technology, applications and the end product of code achieve massive adoption and awareness at such a massive level so quickly.
Pokemon Go is already a fascinating case study for programmers. So let’s take a look at 5 key criteria from a development standpoint and see what we can learn from Pokemon Go:
- What has Pokemon Go done poorly that it could fix?
- What are some unfair criticisms of Pokemon Go?
- How did Pokemon Go come to be?
- What has Pokemon Go done well?
- Most importantly, what can we learn from Pokemon Go that will make us better programmers?
What has Pokemon Go done poorly?
The game isn’t reliable.
It would be an incredible understatement to say that Pokemon Go’s reliability is lackluster. If you started catching monsters in July, you’ve probably run into a ton of frustrating situations, like a hanging loading screen or confusing error message after launching the app.
As a user, it’s super de-motivating when you’re unable to engage with an application that you find interesting. But it’s hard to blame the developers too much. Here’s why:
In order for Pokemon Go to function properly, it needs to connect to a central hub application, called a server. The server coordinates the game dynamics across each user’s account. This hub application transfers data from a single source to various mobile devices across the world. This server, the central source of information, usually consists of multiple computers, in what is known as a datacenter.
45 million DAU is an insane amount of people trying to access the same resources at the same time.
Think about it this way: If 1,000 people were trying to use Microsoft Word on your computer at the same time, you’d likely see a lot of spinning beach balls.
But how are problems like this solved in the real world?
Most developers don’t spend a lot of time working on scaling applications to support more users. Most developers focus on building new features, fixing bugs, and fixing other features on behalf of the users of the applications.
In order to support massive scalability at a rapid pace, the role of DevOps is critically important. DevOps is a role related to a typical developer. But it’s the type of developer who builds code designed to empower other developers of the product. For this type of developer, things like features and bugs (unless related to the infrastructure they’re building) are an afterthought.
In most small companies and startups, DevOps is a niche role. Many of these companies employ a single DevOps developer for every 10 or 20 other developers. This is because most companies don’t experience the viral growth that Pokemon Go went through. But if you do want to scale at that rate, DevOps is the only way to make it happen.
DevOps engineers use tools like Chef or Puppet to write computer programs to buy virtual computers (called VPS or Virtual Private Servers) and install the programs that need to run the code. They can also write programs that enable these machines to pitch in and do work too.
The game doesn’t have an official status page.
For most web applications, having a real-time status updating page isn’t insanely important. If your application is generally reliable, and this feature certainly isn’t required.
But plenty of companies do have status update pages. For example, check out GitHub’s, Heroku’s, and Vimeo’s. These status pages are designed to help people understand three key things:
- If/when there is a problem
- Why the problem happened
- How to determine when the problem is fixed
Given the fact that Pokemon Go has had frequent outages, users relied on Twitter and @PoGoServers, an unofficial twitter handle for updates. Additionally, unofficial status pages like ispokemongoupornot.com, pokemongostatus.com, and more chipped in to try to clarify problems for users. These unofficial avenues help in some ways, but it’s certainly not ideal…particularly for two key reasons:
- They aren’t official, so they may not detect certain outages
- They don’t help the company communicate what exactly they’re doing to address the issues or the ETA on fixing them.
For most companies, this isn’t a major, major issue. But given the frequency of Pokemon Go outages, it’s pretty critical to maintain clear communication with users.
In general, the game doesn’t communicate well with users.
The team at Pokemon Go has made some pretty bad mistakes when it came to communicating with their users. And not just with downtime. They’ve done a poor job communicating plans to add features, and even a poor job explaining the reasons why the changes were happening.
It uses extremely generic error messages.
The other day, I tried to log into the application and was faced with a generic “cannot login” message. This doesn’t indicate a few key pieces of information:
- Is this because the server is down?
- Is this because my credentials are incorrect?
- Is this because my account is broken?
- How can I fix this?
Given the frequency of the problems with the game, clear and specific error messages are critical. This would help out the user experience much more than adding new features.
Help me play the game you’ve built. Don’t change the game!
It has a poor onboarding process.
The first step in my onboarding process for the app was to create an account. To do so, the app launched a web browser and showed me a non-mobile-optimized web page to sign up. Many of today’s applications are mobile first, where the design of web properties is prioritized on the mobile side. The thought process behind this is that if you only have the real-estate of about the size of a credit card, you need to utilize that space very efficiently.
Not using a mobile-first approach to the account creation process for a mobile game is pretty unforgivable. For me, it was a very frustrating part of the experience and I would have given up if I wasn’t so motivated to run around and catch fake monsters. Transitioning between different mediums in the initial process is known as friction in the sign-up process. Most applications seek to have as little of this as possible.
Pokemon Go bans cheaters for life.
The people who are cheating at the game probably love it. And while duct-taping an iPhone to a ceiling fan isn’t what the game designers intended, I’m not convinced that it’s worthy of a lifetime ban.
The developers kept adding features despite not having a stable product.
As a developer, it’s typically not a good idea to add more uncertainty into the mix when scalability issues are already happening. But despite having fairly major scalability issues, Pokemon Go kept adding new features. This is the equivalent of building new rooms and decks on top of a sinking cruise ship.
The craziest part of all of this is that all of these issues haven’t really mattered.
My friends were playing. People on YouTube were talking about it. Even Soulja Boy joined the movement. So ultimately, it didn’t matter. The fact that Pokemon Go has been able to overcome such major obstacles is a testament to how awesome the experience of playing actually is.
What Are Some Unfair Criticisms of Pokemon Go?
It’s not Pokemon Go’s fault that it kills battery life.
Pokemon Go has gotten a lot of flak for draining phone battery fairly rapidly. But it’s pretty unfair to blame the app for this result. The game drains battery because it uses two fairly battery-intensive components of the phone:
- Pokemon Go constantly uses your phone’s GPS.
- Pokemon Go frequently accesses your phone’s camera.
Both of these uses are central to the point of the Pokemon Go experience. Without using the GPS to track the user’s geographic location, you couldn’t replicate the experience. Augmented reality applications are so new, and the idea itself is fairly battery intensive. This is a hardware problem, not a software problem.
Problems at this level will ultimately need to be fixed by the manufacturer of the phones. Not the developers of applications. Either Apple or Google or other phone manufacturers will need to either build more robust batteries to store even more energy. Or, as another option, the operating system for the phone will need to make these aspects of the phone require less energy.
There is nothing the developers at Pokemon Go can do to fix the battery issues with their game. So just make sure to charge up before lacing up your shoes and visiting your nearby Pokemon Gym.
It’s unfair to blame Pokemon Go’s for the potential danger involved in playing.
The experience is incredibly immersive. It’s true that carelessness while playing the game can lead to injury, but users should accept responsibility and only play the game in locations where it is safe to do so.
The Perception Is That Pokemon Go Is An Overnight Success. But It Was Actually Many Years In The Making.
Pokemon Go’s backstory is quite fascinating. Niantic, the company that developed the game, started as an internal team at Google in 2010. The team built several mobile-based experiences. The first was a Field Trip, which provided insights about the nearby locations The second was Ingress, an augmented reality game.
Then, later in 2015 they spun off from Google and became their own company. Partnering with Nintendo, the Niantic team was able to leverage the data they’ve been collecting previously to populate the Pokemon game with valuable information:
“The Pokéstops are submitted by users, so obviously they’re based on places people go,” Hanke said. “We had essentially two and a half years of people going to all the places where they thought they should be able to play Ingress, so it’s some pretty remote places.
“There are portals in Antarctica and the North Pole, and most points in between.”
—John Hanke CEO of Niantic [Source: Mashable]
Despite Its Shortcomings, Pokemon Got So Many Things Right
The game uses the Unity 3D Engine.
According to Sean Grogg, Pokemon Go uses the Unity game engine. The role of the game engine is to bridge the gap between the things the game developers draw on a screen and what the users see on their device.
The Unity game engine was used in Angry Birds 2 and many other games that look flat out gorgeous. So this decision by the creators of Pokemon Go gave them a solid foundation to build a beautiful user interface.
Sponsored stops are pretty revolutionary.
According to TechCrunch, Niantic partnered with McDonald’s and turned each McDonald’s restaurant in Japan to a Pokemon gym. For years, companies have been trying to figure out how to use mobile devices to push people to brick and mortar locations. The fact that Niantic figured out a new, innovative way to do just this is super cool.
This means that Pokemon Go is a competitor to both daily deals companies (think: Groupon, LivingSocial, etc.) and mobile payment companies (think: LevelUp, Apple, Square, etc). It’s remarkable that something as trivial as Pokemon Go can succeed in an area where goliath tech companies have been working in for years.
Pokemon GO has smart database-level decisions.
Again, according to Sean Grogg, Niantic is using either Cloud Bigtable or Cloud Datastore for their database backend. One of the hardest aspects of scaling massive applications involves scaling things at the database level.
For context, Cloud Bigtable is the same database service that power’s much of Google’s web properties. This means that at the database level, Niantic shouldn’t need to worry about running into scalability issues.
While they haven’t been perfect, overall Niantic has killed it and we can learn a lot from their execution.
Every decision you make when building a company or a product like Pokemon Go involves trade-offs.
Better preparation with DevOps could’ve made the launch a bit less rocky, but it would’ve taken more time to do.
Communication could’ve gone smoother, but that would make things a bit slower in the process.
The fact is that right now there are 30 million people catching invisible monsters every single day. That means that there are more people playing Pokemon Go than there are living in each of these cities: New York City, Los Angeles, Chicago, Houston, Philadelphia, Phoenix, San Antonio, San Diego, Dallas, and San Jose. Oh, and also the entire state of Massachusetts.
All of this happened in less than 2 short months.
It’s really incredible to think about the amazing things you can do with code in such a short amount of time.
If you found this post insightful, share it using the Facebook and Twitter buttons below.
