Electronic Vote Fraud: A Programmer's Perspective

[quark219]

I work in the IT division of a large corporation and have a
background in computer programming, primarily mainframe COBOL.
What I'd like to do in this post is explain to nonprogrammers
how a programmer would approach the stealing of an election.
To do this, I'll use something called pseudocode. Pseudocode
is fake programming that would never run in a machine but that
explains the logic behind a given operation--in this case, the
stealing of an election.

To begin, the first thing that's needed is a table of flip
values. By this, I mean a table explaining to the operatives
of the vote fraud how many of their opponent's votes they need
to flip over to their side in order to win an election. For
example, let's say there's a close race where the latest polls
have the Republican getting 50% of the vote and the Democratic
challenger also at 50%. In order for the Republican to win
strongly enough to avoid a recount, and with some margin of
safety, it will be necessary to flip about every 25th vote
cast for the Democrat to the Republican. This would yield a 4%
margin of victory to the Republican: 52% to 48%.

Consider that again: In order for the Republican to steal the
election by four percentage points, you need to flip ONLY
every 25th vote cast for a Democrat--which in a tied election,
would mean that, on average, just every 50th vote cast would
have to be flipped. The other 98% of the votes cast would not
be touched. This explains why reports of machines flipping
votes are sporadic and easily attributable to human error.

In the event that the 2% of the people whose votes are
manipulated notice something and have the self-assurance to
speak up, how likely is it that the poll worker will be able
to detect the problem? If the poll worker decides to check the
machine, chances are he or she will cycle though about a dozen
test votes and determine that "everything's fine,"
not understanding that to detect a typical flip value, 50,
100, 150, or more test votes would need to be cast.

To correctly select the flip value, as described above, the
perpetrators would require a carefully worked out flip value
table. In the first column, you'd display the percentage
breakdown of the Republican and Democratic candidates, as well
as the undecided votes, according to polling data. To the
right of each percentage will be the flip value necessary to
procure a Republican win by a given percentage. The targeted
winning percentage, I'm guessing, would be about 4%. 

Republicans who are far behind the Democratic opponents would
probably not be given enough flips to ensure a win--just
enough to significantly help their chances. I would guess that
flip values of less than 25 are avoided because it would
increase the risk of detection substantially.

The next task is to get the flip value, once determined, into
the machines in a given district. To do so, you'd use a
variable and a patch. A patch is a small bit of maintenance
code added periodically to keep the machines running smoothly,
a form or routine maintenance. If you use a 
variable for the flip, your operative has to install just ONE
small line of code -- the "NEW-FLIP" value, let's
call it -- in the maintenance patch in order to steal the
election.

That "NEW-FLIP" value could be given any name
desired and buried among hundreds of lines of perfectly
innocent code.

Here's the pseudocode that would be used inside the machines
to pick up the variable (NEW-FLIP) and use it to steal the
election. Again, this is simplistic pseudocode, written with
the intent of getting nonprogrammers to understand how a
programmer would go about the problem.

- - - - -
LET NEW-FLIP = FLIP.

SET DEM-VOTES = 0.
SET REP-VOTES = 0.

START

ASK FOR VOTE

IF VOTE-CAST = D THEN LET DEM-VOTES = DEM-VOTES +1

IF DEM-VOTES = FLIP
     THEN LET VOTE-CAST = R

DISPLAY VOTE, CAST VOTE, SET VOTE-CAST = NULL

GOTO START.
- - - - -

If it seems simple, it is: Electronic vote fraud is easy to
do, but hard to detect.

I hope this opened some eyes.