Кодер

FUN REMOVAL
Coder	Доступ: Github, #coderbus Сложность: Very Hard Глава: Headcoders Обязанности: Remove fun, squash bugs. Руководства: Understanding SS13 code, Guide to contributing to the game, SS13 for experienced programmers, Others

Coders are high priests capable of manipulating the Source Code, which is held in the center of the Repo. The job of Coder is a prestigous one, and few can achieve this elevated position. The Coders are assisted by the Spriters, which shape the ideas of the coders, and the Mappers, who build the worlds that the Coders influence.

Becoming a Coder

The path to becoming a Coder is a long and winding path, littered with drama, BYOND being a laggy piece of shit, undefined variables and infinite loops. The journey is well worth it though, because once you are a Coder, you have the ultimate power to add anything to the game!

To become a Coder, you must first read the Necronomicon, and then sacrifice your firstborn to summon a Git. You must then Raise this Git until it reaches adulthood. This process may take several years, and the Git mortality rate is high.

When your Git is fully grown, any Commits you give him will slowly add to your power. Once you are confident enough with your power, you must peform an arcane ritual known as a Pull Request. A Pull Request will take any Commits your Git currently has, and relay them to the Repo, the metaphysical entity connecting all Gits. Imagine Goku, but with a gun. Maybe even two. The Pull Request will not go unnoticed, however, and other, older Coders will show up to review your Commits before they accept the Pull Request. The older Coders, also known as Maintainers, will be harsh when judging your Pull Request, but they have sworn an oath to keep the Repo clean from Copypasta, Snowflakes and the feared Runtime Errors.

A new Git being born.

The Source Code

The Source Code is what the universe is made from. Hosts, commonly known as Gods, take the Source Code from the Repo, which exists beyond all universes, and use it to make their own universe in the great void between all the existing universes. This void is known as The BYOND.

Not much is known about the BYOND, except that it works in strange ways. A few prestigous Coders have attempted to decypher the secrets of the BYOND, but they had to repay with their sanity. It is because these brave Coders sacrificed their lives that the Coders of today can manipulate the Source Code.

The Coderbus

Once his first Pull Request has been accepted, a Coder is allowed in the Coderbus. This is the great hall where the Coders meet. Many activities can be practiced here, including, but not limited to:

• Git Competitions
  • Git Racing
  • Git Grooming
  • Git Shows (The most prestigous of all of them, few can truely master their Git)
• Rational Debate
• Teaching
• Drinking

While the Coderbus is meant mainly for the Coders, anyone may wander in and listen to the debates the great Coders have. However, they are not allowed to participate unless they are a Mapper or a Spriter. Many have tried to voice their ideas in the Coderbus, and they have been exiled from it.

Fun

How Coders think about Fun

The Coders, being high priests, always attempt to hold their grip on the masses. They do this by removing fun. Fun Removal is an intricate procedure and can be done in a number of ways, but the most common one is the Nerf. Nerfs are so common because they are easily made and discourage the masses from revolting. Another fun-removal that is commonly practiced is the closing of Exploits. Exploits are ways for the masses to easily abuse the Source Code, which angers the Coders. The Coders will always close Exploits when they can.

We can conclude that Fun Removal has become a true art amongst coders, and the skill of a Coder is often measured in the amount of fun he or she has removed. The Coders that remove the most Fun eventually transcend Coderdom and become Headcoders.

Headcoders

The Headcoders are, as the name implies, the Elders amongst the Coders. They have transcended normal Coderdom and are in direct contact with the Repo. They decide whether a major change to the Source Code may pass or not. It takes many years of practice slacking off to become a Headcoder, and each Headcoder has his or her own speciality. Headcoders rarely leave the Coderbus, to the point where they become so detached from the masses outside that they will blindly let any change pass they deem worthy, despite the fact that this change will surely enrage the masses.

Being a Headcoder for too long will cause severe brain damage to those that do not possess a will strong enough to carry the weight of the Source Code. Many have become asocial, easily enraged and unable of rational debate.

To become a Headcoder, one must defeat one of the previous Headcoders in his or her expertise in a day-long Coding duel. The one who can make the best changes in the least Commits wins. The winner has to rip the heart out of the loser and eat in on midnight. The winner will become the new Headcoder and his soul will forever be connected to the Repo, until another challenger appears. The overturn of Headcoders is higher than one may expect, since the Source Code slowly degrades the mental capabilities of Headcoders.

Natural Death

As with all things, the Coder lifecycle ends with death. As previously noted, this can happen in the early stages of a Coder's life during the growth of their Git, or when too many Pull Requests get denied, but even coders who have matured are not free from death, as they get older, the chances for the natural death increase.

After feeding off of the Repo for a while, the coder ages and their Git continues to grow in power. When their Git has reached a certain level of power, the coder may consider attempting a system overhaul involving a core section of the Source Code. Some coders manage to survive this temporary symptom without attempting it, preventing damage to themselves and the Source Code, this generally increases their lifespan by a large amount, as they will eventually build up a strong resistance to the idea, if they come across it many times.

Unfortunately, many coders are claimed by this symptom, and the natural death cycle begins. The first stage of this process typically involves the coder begin somewhat erratic behavior, as they scan through the Source Code of the existing system, researching how it works. In this stage the coder may turn back, as they will come across various other systems that are integrated with the one they are trying to overhaul, and observe the terrible language of the younger, less mature coders before them. Some coders already know the system well, so they may skip to stage two.

Stage two is when the Coder starts the actual development of the rework, having already sufficiently figured out how the system works, they use their Git to make the overhaul into a reality, scraping up old code and replacing it with new, better code. Depending on their Git's power level, the coder may spend days, or months in this stage. Stage two is generally considered the point of no return, where the coder cannot turn back and the process of natural death will be seen through to its end.

If the Coder survives stage two, they move into stage three. At this stage, the coder has a completed overhaul and creates a Pull Request to the Repo, as they have done many times before. This time though, Maintainers may shy away from reviewing the overhaul depending on its size and intimidation factor, for fear of prematurely beginning their own death cycle. Depending on the strength of the Coder and their Git, they may eventually convince a Maintainer or Headcoder to review the Pull Request, but this inevitably ends in the Maintainer summoning Feedback, which hurts the coder, since the coder has to either: defeat the Feedback, or depending on the elemental type, surrender to it, and allow it to merge with the overhaul.

At any time after stage two, the death cycle can end promptly and without notice. When this occurs, the coder's body dies as their Git permanently breaks away from the Repo, slowly rotting away, and losing its power. The ghosts of dead coders can still dwell around the Coderbus, as the soul of a coder is bound to it. Coder ghosts can also be seen in the Repo to moan at the living, but since their Git is no longer with them, they cannot make any more Pull Requests.