SDCC Just Didn’t Think About The Ladies This Time.

I normally never critique a company for not hiring female devs or DBAs; I tend to think it’s the responsibility of women to be good enough to deserve employment. This time, however, I think it’s quite appropriate for a system that seriously screwed with women who have two last names after marriage.

I’ll start by saying I got my San Diego Comic-Con badges just fine. Two 4-day with preview night badges successfully purchased for myself and my husband…but it nearly didn’t happen, and it certainly didn’t happen because I followed instructions.

You may all remember the giant cluster that was last year’s registration process. Comic-Con spent an extra five months trying to fix their problems concerning server balancing and site overload. They set up a system using preregistration for member IDs that had to be verified in advance. I applaud the effort; it seems that with a few hitches, this year went much better than last. There were two
serious issues, however.

In a predictable moment, the link included in the Comic-Con registration email (http://www.comic-con.org/cci/badge_sales.php, for all of you who maniacally clicked it hundreds of time) went down due to tracking on the URL from the email. Their tracking and analytics system was their bottleneck. As a dev, I had some advantage here, since I expected that to happen and had already set up two machines in front of me with two different browsers and the link pasted into the address bar ready to hit ‘enter’. I popped in at #1906 in line on my main box in FF and #3222 on my netbook in Chrome.

Turns out that in a moment of epic (pun intended, as Epic Registration is the in-use system) failure, San Diego Comic-Con Member IDs created by people with spaces or punctuation in their names were utterly useless. In the badge registration email, I was told to register with the last name of VLACK, though my last name is Wheeler
Van Vlack. After VLACK didn’t work, I tried WHEELER VAN VLACK and was deeply fortunate that it worked. Chelsey St. Juniors has a space and period in her last name, and missed out on her badges entirely, since the information in her badge registration email was incorrect.

Others complaining on Facebook say that people with a space in their last names have not received confirmation emails. One woman’s comment (Lisa Wong Rodriguez, if I remember correctly) concerning her Member ID and last name not working has been deleted.

People on the Comic-Con International’s Facebook page who are commenting on this issue are being deleted, or so they claim. In a bit of investigative journalism, I’ve posted a comment there as well and already received a response. Far from deleting my comment, Comic-Con has acknowledged that they screwed up people with multiple last names. Still, note Tina’s comment at the bottom.

I want to congratulate Comic-Con for acknowledging their fault, but really–how many men have two last names like these women do? I’ll pay Comic-Con the compliment of assuming there were no talented female devs or DBAs available to do a quick smoke test for stupid.

__________________________________

QUICK UPDATE:

Comic-Con has responded to my post on Facebook, and they say that the system was broken for all
people who had strange last names with any spaces or punctuation. I absolutely agree: their system was broken. They assert that because men sometimes have spaces and punctuation in their last names (Sr., Jr., etc), that they were affected too; I heartily concur. I never said that this was a deliberate attempt to keep women out of Comic-Con; what I said was that hiring a woman to look over the system might have prevented this problem. Women were, I think, disproportionately affected by this error–and I’m open to refutation on this point. I think that, proportionately, there were more women with multiple or hyphenated last names who didn’t get their badges than men who have a Sr. or Jr. tacked-on.

Third Edition Earthdawn Dice Roller in Java

So, I play an RPG called Earthdawn; it’s a lot like D&D, but for real nerds.

One of the things we all do in my gaming group is write our own dice rollers; rolling actual dice is SO passé–and there’s an ongoing argument about whether or not a seeded random is more or less random than the natural flaws in dice and rolling surfaces. Java is the language in which I learned to write math, so I somewhat naturally write algorithms in Java without thinking. It’s easy enough to translate this into C# or whatever.

Ok, so, here’s the algorithm. In Earthdawn, dice rolls are predicated on the step level of the difficulty. You may have an attack roll at step 18 and a damage roll at step 22. In 3rd edition Earthdawn, that translates to rolling d12+d10+d8 to attack, and 2d12+2d6 for damage. Here’s the chart (click to embiggen):

As you can see, there’s some kind of progression here; it turns out that the algorithm is a simple infinite series. There’s a jump in the number of dice every seven steps. Hence, the algorithm has a few simple steps:

(1) Divide the step number by 7.
(2) Determine and store the floor and the modulus.
(3) Roll a number of d12s equal to (floor – 1).
(4) Roll dice equal to the corresponding modulus (the first addition of dice past the 7 threshold will be 2d6, so if the modulus is 1, 2d6 are rolled and added).

That is the step algorithm such that no lookup is now necessary; Earthdawn has exploding dice and epic
fails, however, so two things are necessary. Look at the exploding dice method; if you roll the maximum value of a die, you can roll it again. You can keep rolling that die until a value shows that is less than the maximum value, such that a d6 rolled with a result of 6 can be rerolled. On the second roll, 6 results. On the third roll, 2 results, so the total value of that die roll is 14. For epic fails, if you roll more than one die and all dice show ones, you have epically failed (similar to a fumble in D&D, and with equivalent disastrous results).

Here’s my dice roller; click to embiggen:

So, here’s the code. It’s intended to be self-contained (you can see that I use a pic of Captain Malcolm Reynolds; just drop a pic in your file structure and reference it in the code if you want a background). Obviously this is bare-bones; you can adapt it at your leisure and to whatever GUI you desire. Any suggestions are welcome; I am always debugging this (and the JavaScript I’m using to display syntax highlighting is a little cranky, so forgive any indentation issues). If you can think of a way to optimize this algorithm, let me know; I always need bragging rights over the guys 😉

package dice;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import 
javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.SpinnerModel;
import javax.swing.SpinnerNumberModel;

@SuppressWarnings("serial")
public class ImagePanel extends JPanel implements ActionListener{

	int six = 6;
	int eight = 8;
	int ten = 10;
	int twelve = 12;
	int dice = 0; //counter for total number of dice
	
	public int middle; //step value entered by me.
	public boolean fail; //whether or not an epic fail happened.
	public JFrame frame;
	public Random r;
	Image img = new ImageIcon("img/MalcolmReynolds13.jpg").getImage();
	SpinnerModel stepEntry = new SpinnerNumberModel(1, 1, 300, 1);
	SpinnerModel karmaCounter = new SpinnerNumberModel(25, 0, 25, 1);
	JSpinner stepSpinner = new JSpinner(stepEntry);
	JSpinner karmaSpinner = new JSpinner(karmaCounter);
	
	private JTextField diceResult;
	private JButton myButton;
	
private JCheckBox myCheck;
	private JLabel enterStep = new JLabel("Enter Step Here.");
	
	public static void main(String[] args) {
		ImagePanel panel = new ImagePanel(new ImageIcon("img/MalcolmReynolds13.jpg").getImage());
		JFrame frame = new JFrame("Tarah's Dice Roller Of Awesomeness");
		
			frame.getContentPane().add(panel);
		    frame.pack();
		    frame.setVisible(true);
	}

	public ImagePanel(String img) {
		this(new ImageIcon(img).getImage());
	}

	public ImagePanel(Image img){
		this.img = img;
		Dimension size = new Dimension(img.getWidth(null), img.getHeight(null));
		setPreferredSize(size);
		setMinimumSize(size);
		setMaximumSize(size);
		setSize(size);
		JPanel panel = new JPanel();
		add(panel, "Center");
		myButton = new JButton("Roll The Dice.");
		myButton.addActionListener(this);
		myButton.setBorder(BorderFactory.createLineBorder(Color.black));
		diceResult = new JTextField("Roll Result", 9);
		
diceResult.setBorder(BorderFactory.createLineBorder(Color.black));
		myCheck = new JCheckBox("Use Karma.", false);
		myCheck.setBorder(BorderFactory.createLineBorder(Color.black));
		GridLayout myGrid = new GridLayout(3, 2);
		panel.setLayout(myGrid);
		panel.setBorder(BorderFactory.createLineBorder(Color.black));
		panel.add(enterStep);
		panel.add(stepSpinner);
		panel.add(myButton);
		panel.add(diceResult);
		panel.add(myCheck);
		panel.add(karmaSpinner);
		setVisible(true);
	}

	public void paintComponent(Graphics g) {
		g.drawImage(img, 0, 0, null);
	}
	
	public void actionPerformed(ActionEvent e) {
		boolean useKarma = false;
		middle = (Integer)stepSpinner.getValue();
		System.out.println("actionPerformed() thinks the step number is: " + middle);
		if (myCheck.isSelected() == true) {
			System.out.println("Using Karma.");
			useKarma = true;
			int decrease = ((Integer)karmaCounter.getValue()) - 1;
			karmaCounter.
setValue(decrease);
		}
		String s = Integer.toString(rollTheDice(useKarma, middle, fail));
	    diceResult.setText(s);

	} 

/////////////////////////////////////////////
/////////////////MATHYNESS///////////////////
/////////////////////////////////////////////
	
	//This is the Earthdawn Exploding Dice Method.
	public int d (int die){

		int sides = die;
		int result = 0;
        int roll;
    
		do {
			r = new Random();
            roll = r.nextInt(sides) + 1;
            result = result + roll;
            System.out.println("This is a d" + sides + " roll with result: " + result);
       } while (roll == sides);

		return result;
	}
	
	public int oneToSeven (int o) {
		int result = 0;
		if (o == 1) {
			result = d(six) - 3;
			if (result < 1) {
				result = 1;
			}
		}
		if (o == 2) {
			result = d(six) - 2;
			if (result < 1) {
				result = 1;
			}
		}
		if (o == 3) {
			
result = d(six) - 1;
			if (result < 1) {
				result = 1;
			}
		}
		if (o == 4) {
			result = d(six);
		}
		if (o == 5) {
			result = d(eight);
		}
		if (o == 6) {
			result = d(ten);
		}
		if (o == 7) {
			result = d(twelve);
		}
		return result;
	}
	
	public int prefix (int p) {
		int prefixTotal = 0;

		for (int i=1; i= 8) {
			int d12s = prefix(full);
			int rest = suffix(mod);
			result = d12s + rest;
			
			if (result == full+1) {
				fail = true;
			}
		}
		return result;
	}
	
	public int rollTheDice(boolean addKarma, int stepValue, boolean epicFail) {
		boolean addK = addKarma;
		dice = 0;
		int result = 0;
		result = step(stepValue);
		epicFail = fail;
		if (addK == true) {
			int dK = d(six);
			result = result + dK;
			if (epicFail == true && dK == 1) {
				JOptionPane.showMessageDialog(frame, "Epic FAIL.");
			}
		}
		else if (addK != true && epicFail == true) {
			JOptionPane.showMessageDialog(frame, "Epic FAIL.");
		}
		return 
result;
	}
}

The IDE Wars: NetBeans or Eclipse for Java Software Development

I’ve been working on several applications for a few years; some are ready or released into the wild. I’ve used NetBeans and Eclipse to develop one application in particular; I’ve written an Earthdawn dice roller application. Earthdawn is like Dungeons & Dragons, but for real nerds. The Earthdawn dice system is complex, including a shifting iterated seven-step algorithm for determining the dice rolled for a given action. In addition, dice explode in Earthdawn. That means that if a given die results in its maximum value (i.e. a d6 result is a 6 or a d12 result is a 12), you reroll the dice and add that to the total, continuing to reroll if the die continues to result in its maximum value and stopping when it does not. Plus, you also have the option of adding a karma die (dependent on race, like Elf or Dwarf) to any roll which permits it.

Obviously, this is a complex system, and dealing with the RNG was not the hard part. The hard part was
figuring out the algorithm by which you can calculate the dice you would roll for any given step. For example, rolling a step 10 means that you roll a d8 + d6. Rolling a step 20 means that you roll 2d12 + d10. You can find this on a chart in the 3rd Edition Earthdawn Player’s Guide, but it actually took doing a Taylor series to determine that there is an algorithm which repeats every 7 steps. This means that my app can calculate what you’d roll for a step 63 dice roll, when the book doesn’t provide a chart that high.

I’ve been fiddling with this app for a year or so, and while I’ve been developing the backend in Eclipse, I found that the frontend needed some serious help. I looked around for an IDE specifically to develop the frontend of a Java app, and NetBeans turned out to be full-featured enough to develop in much the same way that I’d dev a C# app in Visual Studio 2010. I’m an old school algorithm coder, and I don’t do as much frontend app development, as opposed to my long term work in
frontend web development. In fact, most of my experience in frontend app development is in VS from 2003 on. So, believe it or not, I was looking for an IDE experience closer to VS.

NetBeans is open source; I found that specifically for the purpose of frontend Java software development, it’s a far better IDE than Eclipse. While Eclipse works better for academic algorithm coding, NetBeans is tailor-made for someone who wants to turn out an app with a backend; in fact, I coded the backend over rather a lot of time in Eclipse to test it with multiple RNGs developed at CERN, Argonne, etc, and simply copied over the relevant classes into NetBeans to hook them up to the frontend. I’d actually recommend this as the most efficient experience if you’re trying to create a complex backend with a simple and effective frontend…especially if you have an app that needs a frontend instead of a script. NetBeans has a simple application package process as well, if you need to pack up the app and send it out. I have
Ubuntu, OpenSUSE, Windows, and Mac users in my group, and Java will execute on each of those platforms.

I’ll also shortly be posting the app so you can examine it for yourselves 😉

“Murder” or “Theft”?

Hello! This is my first post over here, so hopefully you all will be kind, and allow me to run my legal mouth off just a touch. ^.^

In honor of the Hallmark Holiday that is the fourteenth of February, I thought I’d revisit an oldie but goodie from the annals of “Seriously? It’s just a game!”

I used to play a number of MMORPGs, and the one that held my attention for the longest was a Korean-based free-to-play one called MapleStory. It was fun and cute and you could play through most of the quests without actually having to interact with
too many people, at least in the States. Where things started getting a little sticky for players and the company, however, was when they introduced the ability to “marry” other players. You got special items and could go on special quests as a couple, and apparently you could have problems in real life as well.

After being dumped by her online husband in 2008, a Japanese woman hacked into his account, and deleted his character. After being interviewed by the police and admitting that she was responsible, she faced up to years  in prison or a $5000 fine. But wait a minute, I hear you saying, can you really “kill” an online character? Should that be punished the same way as “real” crimes?

It’s not clear from the various news stories who focused on the jilted lover aspect of the story, but it’s likely that the crime for which she was punished was the “hacking into his account” and not so much the “deleting his character.” In the States, we have the Computer Fraud and Abuse Act (
CFAA) which makes it unlawful to use someone else’s login information to do illegal things, and Japan probably has similar provisions. Technically, even if she’d had his information for legitimate reasons, she still could have been prosecuted, because there is a provision about “exceeding the authority” to use that account or computer.

Even if she had been within the law in how she accessed his character, did she break the law by deleting his character? Is an avatar “human” such that it can be “killed” under the law? Well, probably not. The worst charge would probably be one of theft or conversion, or malicious mischief at the lowest end. And online games have an additional layer of complexity about who owns pixels, because with “free-to-play” and online games there isn’t a physical transfer of ownership which would constitute a “sale” in the legal sense.

Even if you pay money to use premium content (like if you want to get married in MapleStory…) the Terms of Service makes
it clear that players lease the game from the developer, and don’t actually “own” any of it. So the spurned woman may have caused problems for her erstwhile lover, but the property she “destroyed” didn’t even belong to him. He was just using it under a license for as long as he followed the rules.

But “Woman Arrested for Hacking Lover’s Computer” doesn’t have the same sense of absurdity, does it?