WRITING SECTIONAL PROGRAMS
by Gary Astleford
Print this Article
  print

Programming difficulty for the average netrunner makes it incredibly hard, if not impossible, for a single individual to write any program of consequence. These rules are designed to solve this problem.

The programming rules assume that the programmer(s) in question are writing the program all at once. However, it is possible to write programs sectionally. In this manner, a programmer can write a program piece by piece. The advantage is that a single programmer can write a very large program. The downside is that it takes a little longer, a separate programming roll must be made per section, and he must make an additional roll when putting the different sections together. More required rolls mean that there's a larger chance that something can go wrong.

STARTING OUT

First, define the program you'd like to write as usual. Decide which components (Functions, Options, and Strength) you want the program to have, and total up the difficulty. Got that done? Good.

Example:
Matthias (a programmer from Queens, Int: 8, Programming +5) wants to write a Hellhound clone. Hellhound (according to CP2020, page 168) has a total difficulty of 40, and the following components: Antipersonnel (20), Movement (5), Trace (2), Recognition (2), Strength 6 (6), and a Superrealistic Icon (5).

The next thing you have to do is break the Components down into groups. Each group must contain at least one component, and the total difficulty of the components in a group must equal at least 10. These separate groups are the different sections of the total/whole program. With me so far?

Example:
Matthias decides to break his program into the following sections: Antipersonnel (Total: 20); Movement & Superrealistic Icon (Total: 10); Trace, Recognition, and Strength 6 (Total: 10).

Now, you've got to actually write the sections. These sections are not functional programs in themselves. More or less, they're like the pieces of Frankenstein's monster. Once you've got them all complete, you can sew them together to make the final product.

A failed programming roll on a section indicates that the code is incomplete, contains errors, or just doesn't work. Unless the roll is a fumble, the programmer will recognize his error, but will still have to take extra time to fix the problem. Time to program each section in hours is equal to that section's total difficulty times six.

Example:
Matt decides to start off with the Antipersonnel subroutine, since it's going the be the hardest one to write. His skill/attribute total is 13, so he needs to roll a 7 or better to succeed. He rolls an 8. This section will take him a total of 120 hours (20 x 6) to write, test, and debug. The other two sections come next. Both have difficulties of 10. Unless Matthias rolls a "1" on either roll, these sections should come out just fine. Each of these sections will take 60 hours (10 x 6) to complete.

It is also an option to have friends or co-workers assist in the programming process. In such a case, the group would merely divide the sections of the program between each other, thereby lessening the time it takes to write them. However, such a group would have to work very closely in order to make sure the sections fit properly, and this is reflected in a slightly higher difficulty number when it comes time to glue the sections together.

Example:

Matt's programming buddy, a 'runner by the name of Tricky Ricky, stops by to help Matt speed up his programming time. Ricky decides to do something easy, so he writes the section that contains the Movement and Icon components.

So, assuming you've made the proper rolls and finished the sections, it's time to glue them together. This requires one final roll. The more smaller sections you're gluing together, the harder it will be to make them all connect cohesively and the longer it will take to do so.

The difficulty to connect the sections together into a complete program is equal to the number of sections times five plus one for each programmer past the first who contributed to the project. The time (in hours) it takes to do such is the connecting difficulty times three.

Example:
Matthias hasn't slept much in the past few weeks, but he's finally finished his programs' sections. Now it's time to compile them into the finished product. The program has three sections, and Matt had help from his friend Ricky, so the final difficulty to connect them together is going to be 16 (3 x 5 + 1). Matthias need only roll a "3" or better to do this successfully. However, it will take him a great deal of time. The connection difficulty was 16, so the time to connect the pieces and completely test the finished product will be 48 hours (16 x 3). Total time to write the program is 288 hours.

Now that you have the program completed, you must determine how big it is. This is done normally, as if you had written the program with the standard rules.

Example:
Matt's finished program is (as near as he can tell) a Hellhound which he affectionately dubs "Spot." The total difficulty of Spot's sections equals 40. If you compare this with the chart on page 169 of the CP2020 rulebook, you'll see that Spot will take up 6 MU of space in Matt's cyberdeck.

Commercially-written programs are not normally completed in this manner. Most software corporations have either large development teams, AIs, or a combination of the two writing their products. While programs written by individuals sometimes take longer to write than the usual corporate trash, they don't normally sell for much more than their corporate cousins do.

Example:

Later that month, Matt is really hurting for some cash. He offers to sell a copy of Spot to a well-funded hotdogger down at the Silver Circuit. Even though the buyer is a weefle, he's not completely ignorant of software prices. A typical, off-the-shelf Hellhound can be got from most connected software dealers (ie, fixers) for around 10,000 euro. Matt's going to have to settle for 10k even though he spent more time and effort on Fido than a typical corporate software team would have.

CONCLUSION
Writing a program sectionally can help individual players overcome obscene difficulty numbers. However, the process takes more time - lots more time - and there's more chance that the player will mess up on a roll, which can mean even more time. In addition, if a group of programmers decide to assist each other by writing different sections, it actually increases the difficulty involved when putting the pieces together, while reducing the total time needed to complete the program. It is possible for powerful characters to spend months writing really bad-ass programs, and the process should be closely monitored by the GM if he's at all worried that rules are being raped.
What's New Guns and Weapons Gear and Equipment Cybernetics and Implants House Rules Netrunning and Net Gear A Day in the Life Recommended Dosages Names and Faces The Man Cyberpunk Sites Wheels and Otherwise Copyright and Legal Statements Out on the Town