Just idle curiosity while the servers are down, but someone’s gotta know this.
How much actual work is involved in, for example, making this change.
Set Bonus (4): Mad Bombardier damage bonus has been reduced to 50% (was 70%)."
Like does someone at Blizzard open a file on the master server, or wherever they keep the holy grail, scroll down a few pages, find the line with set bonus multiplier, change it to +.5, make a note somewhere and hit save? Do they copy paste the line and change the value, then pound out the old line?
Like how does an actual game company make updates to the code?
nah but the real answer is yes all of that but then because theyve made 100 systems (Systemlands) they have to test it to make sure all the covenants, conduits, abilities that proc from it, talents, legendaries, torghast abilties, pvp and all that are working because updates to the code has butterfly effects on everything else. my guess anyway, someone could elaborate further on the specific parts.
For changes like you described it would be a small check in probably, but we really don’t know what other stuff they are fixing or doing in the background to make some of these longer maintenances. Could be a very small build update that has an important bug fix, but that might require all servers to come down for longer to deploy it.
Also we don’t know how much technical debt they are dealing with at this point with an old game like this. Some things might just be done the way they are because they were designed in such a way a long time ago.
Generally a dev would make a feature branch, make the change, and then make a pull request. The person receiving the request would review and merge the update to master.
The repo tracks the changes, date, and who made it.
Business owners have to make a user story so they have to get together and decide what it is, what the acceptance criteria is, and everything involved. Story is approved by scrum master and added to sprint. Story is assigned to dev with some point value depending on how much work the dev thinks it’ll take. Dev gets to work, puts it into testing. QA tests it, puts it in sign off. Business approves. The code branch (probably Git or some other SVC) is then pushed to stage, where it might be tested again, and then pushed to prod once it’s determined to be acceptable and stable. Pushing to prod is probably part of what happens on Tuesdays.
But take what I said with a massive grain of salt because I’m making a lot of assumptions.
What probably happens is that a dev will clone from the main branch onto his local, then make a new branch from that main. Then make his changes, commit them, and then push back to the primary code repository (on a dev environment.). Then he’ll do a pull request, where a senior dev will look over his changes, and merge them back into the main branch on the repository if it passes.
Then likely some dev ops software, like OctoDeploy and Teamcity will be used to move those changes to a stage and prod environment.
If Blizzard us using old copy and paste techniques . . . tuesday maintenance would be a nightmare lol.
There are a LOT of ways to build software depending on purpose, requirements, etc.
Could just be editor/application driven. An interface may have been designed that allows for numbers to be changed (% adjustment to damage for example) by ‘anyone’, without a DBA or coder being involved.
The same feat could be/is done via direct database scripts, or ‘hard coding’ which would require a programmer (software code modification).
I’d be guessing the former though.
Edit: But that hasn’t addressed the ‘analysis’ of the change itself based on projected performances across content against every other spec, class, future goals/changes coming in, etc. That’ll be a whole different can of worms.
Depends on how the code is written. The best practice in this area would be to have code which is “table driven” so the code itself doesn’t have to change, it just picks up values out of the tables.
As for the tables themselves, they could be
… “static” meaning they are defined in a source code table which would be recompiled and linked into the system or they could be
… “dynamic” meaning there’s a in house utility that allows them to change the table on the fly.
Most likely those things are changed dynamically. They might even be in a relational database.
Something like this should just be adjusting a value, but you also need to look for unintended consequences if for example, something else is triggered by it when it reaches a certain threshold. Things can domino in strange ways you don’t expect.
This is most likely managed in WoWEdit inside the Item Management UI section of their tooling and it’s really as simple as opening up the tier bonus screen, modifying the multiplier, and hitting save.
Their tooling is capable of generating the diff for the change, prepares a SQL migration script that will get applied to QA when the changes get promoted for testing and then that same script will then be queued up for promotion to production when its ready to be released either as a scheduled maintenance task or a hotfix.
Using this automation removes human error and also avoids the need for DBA review of all SQL changes that get promoted to production, because believe me DBAs are very protective of their databases .
Most of the time spent by the developer is really actually running sims and testing the change in development before, but the actual numeric change is frankly seconds of work.
As is with most changes, you spend more time documenting and testing a change than you actually do creating the change itself.
The game servers load these values into memory on start-up for fast cache and access to avoid IO latency with reading database tables at runtime and there are events that get triggered when the table is updated via a hotfix so those changes get patched in without requiring a server restart.
The ones that actually develop the client internals for rendering/networking, WoWEdit, and any other tooling they need, do use some form of version control; however, the Game Designers aren’t always from an IT background and do most of their changes via WoWEdit directly that handles all that fluff behind the scenes.
Don’t forget Ion was a lawyer turned Game Designer .
.
.