This Developer Blog is copied verbatim from the RuneScape website. It is copyrighted by Jagex.
It is written by Mod Duncan and is dated 27 August 2009.
Changing Names

I’m Mod Duncan, one of the members of the Web Systems team at Jagex. A lot of the work we do in Web Systems goes on behind the scenes, so you may not notice much of it (except when things go wrong), but we're responsible for developing and maintaining all the website systems that support our games, manage your accounts, offer website features like the hiscores and forums, handle payments for membership and all the rest. Most of the time the effects of our systems are limited to the website, but the work I’ve been doing over the last few months will be a lot more visible when it finally launches.

The project I’ve been working on since January (according to version control logs; it seems a lot longer) is called Display Names and, as various hints dropped on the forums and Twitter feeds might have led you to believe, has the goal of allowing players to change their names.

So why, you might ask, has it taken so long? It’s a common occurrence in the programming world that the easier something is to describe, the harder it is to implement, and this project has been no exception. So, make yourselves comfortable, and I’ll lead you through the long and convoluted process of implementing the simplest sounding of ideas: "let players change their names". It can’t be that hard, can it?

Humble beginnings

The beginnings of the Display Names project hark back even further than January, before I was even involved. Back then it wasn’t even called Display Names, and the goal was subtly different - we just wanted to make it easier for people registering new accounts to find a username that wasn’t already taken.

There are millions of accounts registered for RuneScape and FunOrb, and thousands more are added each day, but only a fraction of those accounts are still used. If we were to go through and delete all the inactive accounts, we could free up their usernames for others to choose. A noble goal, to be sure, but alas (as is so often the case) it didn’t last in the face of the technical details. At this point in our narrative a brief digression into the architectural design of the Jagex back-end servers is in order, that you might understand the issues we faced.

The systems we maintain are broken up into many individual applications (we call them ‘modules’), each of which handles a generally quite small part of maintaining the games and accounts. For example, there’s one module that handles creating new accounts; there’s one for polls; another for showing the hiscore tables. The bigger systems, such as handling offences and appeals, are spread over more than one module. Each of these systems stores its own information, and whenever players are concerned we store the information against their usernames. Generally, this makes our life a lot easier, as we can update individual modules without affecting the rest of the systems. However, in this particular case, it made our life a lot harder.

Deleting a user from every module where they might have an entry wouldn’t be something we could do instantaneously, so our first hurdle was what to do if we’d decided someone was "inactive" and they had the temerity to start playing again halfway through the deletion process. Unlikely, you might think, but with the millions of accounts we have, these sorts of troublesome events become more and more plausible. Even if we’d found a solution to that issue, we discovered there was information in the Billing systems that we were legally obliged to keep, which made it even more complicated.

In the end, we gave up on the idea of deleting accounts and considered the alternative - just deleting their names.

What’s in a name?

It’s around about this point in the tale that the project became ‘Display Names’, and, shortly after that, I became involved. The new goal was to add a second ‘name’ to every account, completely separate from their username. Then we can do what we want to the display name on the account without affecting our data storage or old accounts. We could even take names away from unused accounts to free them up for other players, and the worst that would happen is that those accounts would have to pick a new name if they wanted to come back to the game.

We even found a number of extra benefits from this idea. With the display name separate for the account name, we weren’t bound by existing restrictions on name length, or the characters it could contain. If we have the facility to take someone’s name away without otherwise affecting the account, we could do something about offensive names without banning the account outright. It’d even make accounts more secure, as a potential hijacker would have to work out your username as well as your password.

As you might guess from the eight months it’s been since this point, even that apparent simple goal wasn’t quite as easy as it made out. Such things never are...

That which we obtain too easily, we esteem too lightly

Once we had the basic concept of the design down, the first stage was picking it all apart again to find the flaws.

Firstly was the issue of making the display name of each account available to all the modules that needed to know it, not to mention the games themselves. Most of the time we could get away with using the login servers, which hold a lot of relevant information about everyone’s account that is fetched whenever that player logs in. However, that doesn’t help us when we’re showing you your Friends List (if your friends aren’t logged in), or on the website when looking at the hiscore tables or the forums. Because we wanted to let players change their names, we couldn’t just store it everywhere, so we needed to have each system look the name up each time. After some hastily scribbled calculations, it looked like the worst case would be around 40,000 of these look-ups per second. That, incidentally, is quite a lot. We didn’t want to throw that much load at the login servers, so there’d have to be a separate system to handle the look-ups as fast as possible.

Technical problems out the way, we considered making the changes as simple and clear as possible to the users. Keeping the Friends List from breaking was probably the biggest issue. If your friend changed their name, we didn’t really want them to stop being your friend, so the list needed to store accounts rather than display names. That would still leave us with players scratching their heads and wondering who these people with strange names on their list were, so we added a feature to the interface that showed each friend’s previous name when they changed it.

Finally, we thought about the ways players might tread on each others’ toes with display names, so we decided to let players ‘hold’ their previous name for a while after they changed it, so if they decided they didn’t like the new name as much, they could still go back to their previous name without someone else sneaking in and taking it. We also made sure that it wouldn’t be too easy to impersonate another player, so similar-looking names wouldn’t be allowed.

Nine parts perspiration

With all the excitement of writing, rewriting and debating design documents finally behind me, it was time to actually work on the module itself. As an added bonus, there was also the work of integrating display names into our other Web Systems modules and working with the Game Engine, FunOrb and RuneScape Content teams to enable them to do the same. Alongside the work I’ve been doing, they’ve all been hard at work making, testing and tweaking their own changes.

Player Support has been working to ensure we don’t inconvenience the players with our changes, and have made many suggestions to make the project as positive as possible. They’ve also been reviewing the tools they’ll need to handle all the new functionality available to them.

It’s this coding that’s been occupying my days for the last couple of months, but it’s finally drawing to a close. The main display names module is currently at the tender mercies of the Web Systems QA team, who are ironing out all the issues and making it as reliable and easy to use as possible. The Web Content team have produced the public interface, and the RuneScape Content and FunOrb teams have been incorporating display names everywhere (the RuneScape Content team were kind enough to share their list of every line of RuneScape’s code that references the player’s name - almost 2,000 different places).

The final stretch

There’s still plenty of testing and work to be done before all this work bears fruit and players can change their names. We need to test that the new system can handle the load of all the requests being made of it, and co-ordinating the launch of changes across all the teams and departments is a mammoth task in itself. Even after the system is launched there’s still plenty of work to do - not only will I need to keep a close eye on the system and fix any issues, but there are plenty of new features we'd like to add in the future as well.

Possessing the natural tendency of developers everywhere to shy away from deadlines, I won’t leave you with any promised launched dates (I’d only doom myself to some catastrophic interruption if I did), but the project’s coming to a close and I’m very much looking forward to the day we can launch it into the eager hands of our players.

If I happen to be out of the country on that day, leaving no forwarding address, that’s entirely coincidental...

Ad blocker interference detected!

Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.