- An Introduction
- Diving In
- The Conference and “Theme”
- Initial Platform Ideas
- Group Gaming
- Initial Design Considerations
- Component Overview
Last October the team at ArchitectNow built a pretty cool thing. We build a lot of software for both mobile and web platforms, but this project was a bit different. First, we developed the platform for a software development conference we are involved with in the St. Louis, MO area called dev up (www.devupconf.org). Second, based on a conference “theme” (described below), we worked to build a platform and applications to engage, entertain, and incentivize nearly 1,000 conference attendees over the course of 3 days. Unlike most of our projects (which are generally work-for-hire engagements where we assist other organizations in launching their own products) we had creative liberty to build an engaging platform to showcase a bit of our capabilities to our peers with the ultimate goal of sharing how we did it in this post (although it took longer than anticipated to write).
Over the course of the 3-day conference the platform supported 390 active gamers, allowed sponsors to scan 6,000 attendee badges, accepted 620 conference session evaluations, facilitated 570 various trivia games, over 1,000 games of tic-tac-toe, and executed over 35,000 Zork commands (yes we integrated the ability hundreds of users to play the full Zork 1, 2, and 3 games simultaneously on the same platform).
This article serves as somewhat of a “postmortem” for the first release of the Ready Developer One platform. Below we will discuss how it came to be, the different games (or challenges) we included, and the different components.
If you are a developer interested in the low-level details of how it was built, we share info on all the technologies we utilized to bring it to life in another post found here: Ready Developer One – Implementation Details. The source code is not open source, but we may share some peeks at it. Open sourcing the code would be difficult as it’s a hosted system with a persistent datastore. We have shared quite a bit about the architecture and all the various tools, libraries, and 3rd party APIs we utilized in development. We hope you find some gems in there that you can utilize in your own development.
We had a lot of fun building the platform and we were blown away by how it was used at the event. We hope you get some value from the information below. If you have any questions regarding anything here please do not hesitate to reach out to me (Kevin Grossnicklaus) directly at email@example.com or on Twitter @kvgros.
Since this post (and the follow-up post on the implementation details) has turned into a somewhat lengthy description of the why’s and how’s of the Ready Developer One platform, I felt it best to give readers the option to dive in and play around a bit first.
Some features of the console are available to everyone while others require you to register a new user.
To create an account, you can type:
You will receive an invitation email with a link to register. Once you have registered an account you can use the console and play all the games. When you return to the console you can use the ‘login’ command to enter your credentials and regain access.
To get you started you can use the following commands:
home – Clear the screen
register – Register a new user
login – Login to the console
logout – Logout of the console
whoami – Get information on the currently logged in user
about – Get information about the console
list hs – Get the current high scores (Top 10)
list c – Get information on the available challenges
list points – Get information on the points the current user has earned
list sessions angular – Lists information on conference sessions containing the word ‘Angular’
list speakers Grossnicklaus – Lists information on conference speakers containing the word ‘Grossnicklaus’
The following commands will allow you to take “challenges” (i.e. play the games the console exposes). Each challenge allows you to earn points in various ways. Some of them are trivia games and others are more involved.
run zork -v [version 1,2 or 3]
Beyond just playing challenges, the console has a large number of Easter Eggs. Type ‘hint’ to get some ideas of what else is possible. (Note: ‘hint’ returns all kinds of different information the more you type it in).
The Conference and “Theme”
Our company (ArchitectNow) as long been involved in the Midwest software development community. We are active speakers and sponsors of many regional events and assist the most with a St. Louis, MO-based conference called “dev up”. We have been involved with this event for nearly 12 years in various capacities. The conference itself brings together nearly 1,000 software developers and other technologists together to network and learn from over 100 technical sessions. The 2019 event was held on October 8-10th at the St. Charles Convention Center in St. Charles, MO.
For the 2018 conference, the organizers decided to incorporate a conference “theme” as part of all communication, marketing materials, sponsor booths, etc. The selected theme was based on the book Ready Player One by Ernest Cline. The theme was chosen due to its pop culture focus and the popularity of the recently released movie based on the book. As a nod to the conference audience we renamed our particular use of the theme as “Ready Developer One”.
For those of you familiar with the book (or movie), the storyline of Ready Player One centers around the characters solving various challenges to find “Easter eggs” within a virtual world called the “Oasis”. Throughout the course of the book the Oasis displays a scoreboard listing the top 10 players and their current point total. The entire story incorporates many different retro 80’s video games, movies, role playing games, and other references. Having such a broad set of 80’s theme content to choose from made the overall concept a nice choice for a conference focused on software developers.
Initial Platform Ideas
As a sponsor of the dev up conference our team initially discussed a variety of things we could do within the framework of the “theme”. We wanted to do something fun (and retro) but also provide value and be useful to attendees. Due to our involvement in helping with some organization tasks we knew we would have access to API’s that provided information on all the speakers, sponsors, and session content. We knew early on that making this data available would be an attractive feature. Also, from our experience in prior conferences, we were very aware that collecting data from attendees (and sponsors) is a technical hurdle faced by every conference such as this. Getting attendees to submit feedback regarding sessions is historically difficult. Also, encouraging attendees to visit sponsors and interact is another hurdle that few conferences easily overcome.
Most importantly (at least to us) we wanted to build something people felt was fun. We anticipated some way of challenging attendees during the event. This meant some type of games or other interactions which we could use to keep score. Following the “Ready Player One” concept we wanted to be able to display a set of high scores and to gauge who was the “best” or the “smartest” geek there.
To this end we asked ourselves the following questions:
- What could we do to get 1,000 attendees playing a set of ‘games’ during the event?
- How could we develop a system where the games started on day 1 and ended on day 3 (a very finite set of time)?
- In addition to games how could we use this platform to solve other problems and incentivize other behaviors during the event?
It was with these questions in mind that we started tossing around ideas for what we could do. Since we were investing the time to build this ourselves (in addition to our other project work) we wanted to be able to showcase how we did it. We also hoped to build a platform we could continue to grow for similar markets or events.
Group games have always been of interest to me. I’m a big gamer in general and that includes board games, RPGs, and video games. Our office contains a museum of retro-gaming systems and a room dedicated to VR (with our own HTC Vive Pro). One area of gaming I personally think hasn’t been fully served is the ability for groups of people to use technology to play social games. My family and friends love getting together to play the various games from Jackbox Games (https://jackboxgames.com/). These games allow large groups of people to interact and play games from the same location while looking at a central screen (we use our Xbox One to “host” the game on a big screen) and using their individual mobile devices to interact as dictated by a particular game (i.e. answer questions, draw pictures, etc). We frequently have 10-20 people in our basement playing the same game with technology facilitating. This concept is fascinating to me and I have not seen vary many other game studios figuring out how to run with the idea of group games (beyond the MMORG or online shooters like Fortnite or PubG).
With the Ready Developer One platform we wondered how we could get 1,000 people online and competing in a casual way. We realized the conference goal is to educate developers and that people would be actively attending sessions and other networking events, so the various challenges had to be easy to absorb and complete without a significant time effort. We also wanted to keep with the overall “retro” theme of the event and make them fun. We knew we had to do all of this within a finite time window. The game should start on day 1 and finish on day 3. We wanted to use this platform to encourage specific behaviors and provide enough value to be useful to people not wanting to actively “play” but just to get some information.
Initial Design Considerations
Our first ideas centered around using Microsoft’s Azure Bot Service and developing an interactive chat-bot that shared information and asked trivia questions. By initially considering developing the platform as a “bot” and using various chat services as the front-end we started down a path that ultimately led us to the idea of a retro “console” (or text-based interface). Growing up in the 80’s many of our team look back fondly on the original Apple II and Commodore 64 consoles we learned to code on. We wondered if we could use modern bot technology to recreate some type of interactivity to achieve our design goals. We then wanted to present an interface for this bot that looked “retro”.
Unfortunately, after some initial prototype work, we decided that the modern bot engines were awesome, but couldn’t easily be molded to our retro console idea. This led us to build our own REPL (Read-Eval-Print-Loop) API concept (described in more detail in the followup post).
We also knew that we wanted to be able to share information about the high scores throughout the conference venue. This would require digital TVs (or other signage) which we might also be able to utilize to share information on conference schedules, sponsors, etc. Having a lot of experience with Raspberry Pi’s we decided it would be possible to post large TVs throughout the conference center and use Raspberry Pis running in “Kiosk” mode to render any content we needed for signage (i.e. scoreboard, upcoming sessions, sponsor info, etc). We thought this would be a fun use of the technology as it was something we hadn’t exactly done before. As described in the implementation post, we ultimately had ten 55” 4k TVs throughout the venue with Raspberry Pi 3 B+’s running FireFox in kiosk mode. This worked very well overall and we can’t wait to come up with other uses for similar infrastructure.
Finally, we knew that one of the behaviors we wanted to encourage (and track for point purposes) was the interaction of attendees with sponsors. The event has 20-30 organizations onsite in an exhibit hall with sponsor tables. Organizers are always looking for ways to encourage attendees to visit and interact with these sponsors. In years past the conference has provided badge scanners to sponsors to scan attendee badges throughout the event. We liked the idea of being able to award some points to attendees every time a sponsor scanned their badge. If an attendee should get their badge scanned by every sponsor at the conference, we would award a bonus. This would encourage attendees to visit and interact with sponsors. The only way this would be possible is if we were able to track attendee badge scans in real-time throughout the event (getting this data after the conference would not have worked). Towards this end we evaluated several commercial mobile badge scanning solutions with API’s or web-hook integration. A few of these solutions emerged as possibilities but none seemed like a solid fit. Ultimately, we made the decision to develop our own mobile badge scanning solution targeting both iOS and Android. We knew we’d have roughly 50 people onsite (sponsors) who would need to be able to scan badges. We had the experience developing this type of scanning software for a few other organizations, so it wasn’t a stretch for us to use this expertise to build a very straightforward scanning solution specific to the Ready Developer One platform. This allowed us to send all badge scans through our own API and then integrate that data back into our challenge/scoring system. At the end of the event we had tracked 6,000 badge scans.
As all the major pieces were designed, we ultimately implemented the entire platform around the following components (the implementation details of each described in later sections):
We decided that the primary interface for the attendees would be a web-based retro “console”. We immediately started brainstorming ideas to make this interface useful and provide many commands and utilities that developers would recognize from the “old days”. Providing a text-based interface opened the possibility of some cool Easter Eggs and challenges but it also posed some challenges for specific ideas. We knew we would need some ability to provide images in the UI. We also knew we had to overcome a steep learning curve for people who didn’t “get” a text-based interface. We weren’t sure how it would be received but we decided to go for it anyway.
We considered developing the console as a native iOS or Android application but quickly settled on a solution that would be web-based and responsive. A key part of this decision was based on timing and the ability to quickly get updates to users should a bug be found. Our entire event would only last 3 days and if anything went wrong, we knew we couldn’t ensure we could get a fix to all 1,000 attendees before the event was over. With a web solution we could be nimbler in pushing updates to users during the event.
Within the “Console” we wanted users to be able to have access to the following features:
- Get information on Sessions
- Get information on Speakers
- Get information on Sponsors
- Evaluate Sessions
- List high scores
- Take Challenges (i.e. play games)
- See what Challenges were available
- Enter commands to perform random “Easter Eggs”
The images below hopefully provide some idea as to what the console looked like and how it works. See the instructions above to use it yourself.
To achieve the above we need to identify a set of text commands that were understandable to the widest variety of users. We spend so much time developing rich web and mobile user interfaces that thinking about interactivity via a command line interface seems very archaic. This provided a fun challenge and gave us something to ponder.
Mobile Badge Scanner
As described above, we decided to implement our own native badge scanning application for sponsors to utilize. This decision allowed us to provide more capabilities than sponsors of this event had been given in the past as well as to be able to collect these scans in real-time via our API. We knew the badge scanning solution would need to be able to function in an environment with spotty internet by supporting offline capabilities and queuing up scans to send to the server when a device goes back online.
The need for a native app was driven by our desire to have access to the camera on iOS and Android devices as well as to work offline. We had written similar solutions for customers in the past and knew we could leverage those lessons learned and some technical assets.
Since our initial event would only last 3 days and we couldn’t risk having a bug fix we couldn’t get deployed before the event was done, we decided to do a manual deployment to the small pool of sponsor users (which eliminated some major risks but also added some additional headaches as described below).
We knew we would need a stripped-down and read-only user interface for display purposes around the venue. As described earlier, these would be powered by Raspberry Pi computers plugged into 55” LED TVs on stands throughout the venue. We knew we could develop a web-based interface displaying the data we wanted. Every morning of the event we would turn on the TVs and the Raspberry Pis and we could have them configured to boot directly to a browser (Chromium) running in full screen (i.e. kiosk) mode that was pointed directly at a URL we specified. The page they displayed was custom designed for the resolution of the target TVs and dynamic enough to refresh the necessary data in real-time throughout the event.
We wanted all logic and data access centralized into a single API. This meant that all mobile badge scanning and web-based console communication would pass through the same JSON API endpoints. We knew we would have a common store for all data and our API would need to reach out to integrate with a few other APIs for data we required from external sources (i.e. sessions, speakers, and sponsors). Any emails or other communication with attendees would be triggered and sent centrally from this API.
All business logic, game scoring, and other complex decision-making logic would be centralized into this service and the “console” and badge scanning front-ends would be thin veneers over the API. With regards to the “console” we knew that the browser interface would simply take user input and send it to the API to execute and then simply display the results.
To give ourselves insights into how the platform was utilized we integrated a number of monitoring tools. When specific events happened (i.e. a login) we tracked that “event” in Microsoft’s Application Insights. This allowed us to see the usage in real time and come back later and look at trends.
- Total players: 390 (there were 954 people onsite but only 390 people logged into the console)
- Total players scoring > 50k points: 26
- Total points amongst all players: 10,113,750
- Total Zork commands entered: 35.19k
- Total sponsor badges scanned: 5.99k
- Total user logins (including duplicates): 1.28k
- Total session evaluations: 820
- Total trivia games started: 688
- Total trivia games submitted: 570
- Total tic-tac-toe wins: 0
- Total tic-tac-toe draws: 603
- Total tic-tac-toe losses: 514
The overall goal of the entire exercise was (initially) to share conference content and engage and entertain the attendees. The conference utilized the platform to encourage participation and they offered up a variety of nice prizes to attendees who achieved a spot in the top 10 on the scoreboard. They gave out Xboxes, HTC Vive Pros, etc. I would like to thank all the players and especially the top 10 pictured below.
The players above pushed everything we did to the limits. Not only did they finish the event in the top 10, they helped find bugs, give feedback, and helped our team keep everything running smoothly.
We had a great time at the event and wish we had all of the content in this point (and the following post on the technology) ready to go much sooner.
We are deep in discussions on the next steps for the overall platform and what we can do to leverage it for other scenarios and events. We have a full product backlog of feature requests for next year. If you are a developer or otherwise interested in the implementation details of all the components described above please check out the follow-up post here: Ready Developer One – Implementation.
Again, we hope you get some value (or at least entertainment) from these posts. If you have any questions regarding anything here please do not hesitate to reach out to me (Kevin Grossnicklaus) directly at firstname.lastname@example.org or on Twitter @kvgros.