HOW TO SHOOT YOURSELF FOOT BY PROGRAMMING LANGUAGES


********** 370 JCL
You send your foot down to MIS with a 4000-page document explaining how
you want it to be shot. Three years later, your foot comes back
deep-fried.


********** Ada
After correctly packaging your foot, you attempt to concurrently load the
gun, pull the trigger, scream, and shoot yourself in the foot. When you
try, however, you discover that your foot is of the wrong type.


********** Ada
If you are dumb enough to actually use this language, the United States
Department of Defense will kidnap you, stand you up in front of a firing
squad, and tell the soldiers, "Shoot at his feet."


********** Ada
You scour all 156e54 pages of the manuals, looking for references to foot,
leg, or toe; then you get hopelessly confused and give up. You sneak in
when the boss isn't around and finally write the damn thing in C. You turn
in 7,689 pages of source code to the review committee, knowing they'll
never look at it, and when the program needs maintenance, you quit.


********** Algol
You shoot yourself in the foot with a Civil War-era musket. The musket is
aesthetically fascinating, and the wound baffles the adolescent medic in
the emergency room.


********** Algol 60
You spend hours trying to figure out how to fire the gun because it has no
provisions for input or output.


********** Algol 68
You mildly deprocedure the gun, the bullet gets firmly dereferenced, and
your foot is strongly coerced to void.


********** APL
You shoot yourself in the foot, then spend all day figuring out how to do
it in fewer characters.


********** APL
You hear a gunshot and there's a hole in your foot, but you don't remember
enough linear algebra to understand what happened.


********** APL
@#&^$%&%^ foot


********** APT
You cut a perfect bullethole in your foot and shoot through it.


********** ASP
You try to shoot yourself in the foot, but the most advanced thing you can
manage is to cut your wrist.


********** ASP.NET
Find a gun, it falls apart. Put it back together, it falls apart again.
You try using the .GUN Framework, it falls apart. You stab yourself in the
foot instead.


********** Assembly
You try to shoot yourself in the foot only to discover you must first
reinvent the gun, the bullet, and your foot. After that's done, you pull
the trigger, the gun beeps several times, then crashes.


********** Assembly
You crash the OS and overwrite the root disk. The system administrator
arrives and shoots you in the foot. After a moment of contemplation, the
system administrator shoots himself in the foot and then hops around the
room rapidly shooting at everyone in sight.


********** Assembly
Any program you write will come back and shoot you in the foot eventually
anyway, so why bother?


********** Assembly
By the time you've written the gun, you are dead, and don't have to worry
about shooting your feet. Alternatively, you shoot and miss, but don't
notice.


********** Assembly
Using only 7 bytes of code, you blow off your entire leg in only 2 CPU
clock ticks.


********** Befunge
You shoot straight up into the sky. The bullet instantaneously travels
around the universe before hitting your foot from below.


********** brainfuck
Just looking at the gun gives you a migrane, so forget about actually
shooting it.


********** brainfuck
You get a lot of little bits of metal and have to build a gun with it.


********** brainfuck
You fire the gun. an atom of bullet disappears and lodges in your foot.
Repeat until original bullet is gone.


********** BASIC
Shoot yourself in the foot with a water pistol. On big systems, continue
until entire lower body is waterlogged.


********** BASIC
You shoot yourself in the foot with a water pistol until your foot is
waterlogged and rots off.


********** BASIC
You shoot yourself in the foot with a BB using a SCUD missile launcher.


********** BCPL
You shoot yourself somewhere in the leg; you can't get any finer
resolution than that.


********** C
You try to shoot yourself in the foot, but find out the the gun is
actually a howitzer cannon.


********** C
You shoot yourself in the foot.


********** C
You shoot yourself in the foot and then nobody else can figure out what
you did.


********** C
If the gun isn't loaded, you get a segmentation fault.


********** C++
You accidentally create a dozen clones of yourself and shoot them all in
the foot. Emergency medical assistance is impossible since you can't tell
which are bitwise copies and which are just pointing at others and saying,
"That's me, over there."


********** C#
You shoot yourself in the foot, but first have to switch to unsafe mode.


********** Clipper
You grab a bullet, get ready to insert it in the gun so that you can shoot
yourself in the foot, and discover that the gun that the bullet fits has
not yet been built, but should be arriving in the mail real soon now.


********** COBOL
Using a COLT 45 HANDGUN, AIM gun at LEG.FOOT, THEN place ARM.HAND.FINGER.
on HANDGUN.TRIGGER and SQUEEZE. THEN return HANDGUN to HOLSTER. CHECK
whether shoelace needs to be retied.


********** COBOL
You try to shoot yourself in the foot, but the gun won't fire unless it's
aligned in column 8.


********** Concurrent Euclid
You shoot yourself in somebody else's foot.


********** CP/M
You remember when shooting yourself in the foot with a BB gun was a big
deal.


********** Cray
I knew you were going to shoot yourself in the foot.


********** Cray
You shoot yourself in the foot with an Uzi.


********** CSS
You shoot your right foot with one hand, then switch hands to shoot your
left foot but you realize that the gun has turned into a banana.


********** CSS
Everyone can now shoot themselves in the foot, but all their feet come out
looking identical and attached to their ears.


********** dBase
You buy a gun. Bullets are only available from another company and are
promised to work so you buy them. Then you find out that the next version
of the gun is the one that is scheduled to actually shoot bullets.


********** dBase
You squeeze the trigger, but someone corrupted the index and the bullet
shoots you in the eye.


********** dBase
You squeeze the trigger, but the bullet moves so slowly that by the time
your foot feels the pain you've forgotten why you shot yourself anyway.


********** DCL
$ MOUNT/DENSITY=.45/LABEL=BULLET/MESSAGE="BYE" BULLET::BULLET$GUN SYS$BULLET
$ SET GUN/LOAD/SAFETY=OFF/SIGHT=NONE/HAND=LEFT/CHAMBER=1/ACTION=AUTOMATIC/LOG/ALL/GULL SYS$GUN_3$DUA3:[000000] GUN.GUN
$ SHOOT/LOG/AUTO SYS$GUN SYS$SYSTEM:[FOOT] FOOT.FOOT
%DCL-W-ACTIMAGE, error activating image GUN
-CLI-E-IMGNAME image file $3$DUA240:[GUN] GUN.EXE;1
-IMGACT-F-NOTNATIVE, image is not an OpenVMS Alpha AXP image


********** Delphi
You try to shoot yourself in the foot but discover that the bullets you
already had are not compatible with the new gun version, but Borland
promises a fix real soon now.


********** DOS Batch
You aim the gun at your foot and pull the trigger, but only a weak gust of
warm air hits your foot.


********** Eiffel
You create a GUN object, two FOOT objects, and a BULLET object. The GUN
passes both the FOOT objects as a reference to the BULLET. The FOOT
objects increment their hole counts and forget about the BULLET. A little
demon then drives a garbage truck over your feet and grabs the bullet
(both of it) on the way.


********** Eiffel
You take out a contract on your foot. The precondition is that there's a
bullet in the gun; the postcondition is that there's a hole in your foot.


********** English
You put your foot in your mouth, then bite it off.


********** FlogScript
Shooting yourself in the foot would be considered cheating. Actually it
isn't, but it is close enough.


********** Forth
Foot in yourself shoot.


********** Forth
Foot yourself in the shoot.


********** Forth
First you decide to leave the number of toes lost on the stack and then
implement the word foot-toes@ which takes three numbers from the stack:
foot number, range, and projectile mass (in slugs) and changes the current
vocabulary to blue. While testing this word you are arrested by the police
for mooning (remember, this is a bottom-up language) who demonstrate the
far better top-down approach to damaging yourself.


********** Forth
BULLET DUP3 * GUN LOAD FOOT AIM TRIGGER PULL BANG EMIT
DEAD IF DROP ROT THEN
This takes about five bytes of memory, executes in two to ten clock cycles
on any processor, and can be used to replace any existing function of the
language as well as in any future words. Welcome to bottom-up programming,
where you too can perform compiler pre-processing instead of actually
writing code.


********** FORTRAN
You shoot yourself in each toe, iteratively, until you run out of toes,
then you read in the next foot and repeat. If you run out of bullets, you
continue anyway because you have no exception-handling ability.


********** FORTRAN
Stab self in foot with sword. Guns haven't been invented yet.


********** HTML
You cut a bullethole in your foot with nothing more than a small penknife,
but you realize that to make it look convincing, you need to be using
Dreamweaver.


********** HTML
<a target="file:///body/lower-half/leg/foot.appendage">Shoot here</a>


********** HyperTalk
Put the first bullet of the gun into the foot of the left leg of you.
Answer the result.


********** INTERCAL
The compiler won't let you shoot yourself in the foot unless you use a
crossbow andask really nicely.


********** Java
After importing java.awt.right.foot.* and java.awt.gun.right.hand.*, and
writing the classes and methods of those classes needed, you've forgotten
what the hell you're doing.


********** Java
You write a program to shoot yourself in the foot and put it on the
Internet. People all over the world shoot themselves in the foot, and
everyone leaves your website hobbling and cursing.


********** Java
You amputate your foot at the ankle with a fourteen-pound hacksaw, but you
can do it on any platform.


********** Java
The gun fires just fine, but your foot can't figure out what the bullets
are.


********** JavaScript
You've perfected a robust, rich user experience for shooting yourself in
the foot. You then find that bullets are disabled on your gun.


********** Haskell
On a warm Saturday afternoon, sitting by the pool with a margarita, you
casually sit up from your chaise lounge chair, reach over and pick up a
gun, aim at your foot, and lazily pull the trigger.


********** Haskell
You shoot yourself in the foot very elegantly, and wonder why the whole
world isn't shooting itself this way.


********** Haskell
You spend several hours creating a new copy of the Universe which is
identical to the existing one except your foot has a hole in it. You then
hear that it can be done more elegantly with Dyadic Functile Hyper-Arrows,
but the very act of reading some of the included sample code causes one of
your metatarsals to explode.


********** Haskell
Your program appears to prevent you from shooting yourself in the foot,
until it suddenly runs unexpectedly out of memory.


********** LaTeX
compy$ cat foot_shooting.tex
\documentclass[12pt]{article}
\usepackage{latexgun,latexshoot}
\begin{document}
See how easy it is to shoot yourself in the foot? \\
\gun[leftfoot]{shoot} \\
\pain
\end{document}
compy$ latex foot_shooting
...
line 6: undefined control sequence \pain


********** Linux
You shoot yourself in the foot with a Gnu.


********** Linux
Generous programmers from around the world all join forces to help you
shoot yourself in the foot for free.


********** LISP
You shoot yourself in the appendage which holds the gun with which
you shoot yourself in the appendage which holds the gun with which
you shoot yourself in the appendage which holds the gun with which
you shoot yourself in the appendage which holds the gun with which
you shoot yourself in the appendage which holds...


********** LISP
You attempt to shoot yourself in the foot, but the gun jams on a stray
parenthesis.


********** Logo
You can easily shoot the gun, but you have to work out the geometry to
make sure the bullet goes into your foot.


********** LSL
Declare the variables for Foot, Gun and Bullet globally. Set the vector
and particle effects for the bullet. Design a dialog box to pop up on log
in. Chain if thens to handle the logic for which foot, which hand and
which bullet. Compile and have the asset server fail erasing all of your
code leaving you to start from scratch.


********** Machine Language
Before you can shoot yourself in the foot you must disassemble the gun at
the atomic level and then reassemble it. After you do this, you find that
the bullets require a special operator so the gun doesn't work.


********** Mac OS Classic
There is no command to do that in Mac OS Classic because there is no
purpose that anyone should need that function.


********** Mac OS X
sudo shoot -p ~/Library/BodyParts/Preferences/foot.plist
KERNEL PANIC


********** Mac OS X
You try to shoot yourself in the foot from the GUI but the gun has
inexplicably turned into a bag of Skittles.


********** Modula-2
After realizing that you can't actually accomplish anything in this
language, you shoot yourself in the head.


********** Motif
You spend days writing a UIL description of your foot, the trajectory, the
bullet, and the intricate scrollwork on the ivory handles of the gun. When
you finally get around to pulling the trigger, the gun jams.


********** .NET
You can now shoot yourself in the foot with any of fourteen weapons,
ranging from an antique medieval crossbow to a laser-guided
Destructo-Beam. However, all these weapons must be manufactured by
Microsoft and you must pay Microsoft royalties every time you shoot
yourself in the foot.


********** NeXT
We don't sell guns anymore, just ammunition.


********** Paradox
Not only can you shoot yourself in the foot, your users can too.


********** Pascal
The compiler won't let you shoot yourself in the foot.


********** Pascal
The gun is mounted such that it cannot point towards your feet, but you
can swivel it round and shoot yourself in the head instead.


********** Perl
You separate the bullet from the gun with a hyperoptimized regexp, and
then you transport it to your foot using several typeglobs. However, the
program fails to run and you can't correct it since you don't understand
what the hell it is you've written.


********** Perl
You stab yourself in the foot repeatedly with an incredibly large and very
heavy Swiss Army knife.


********** Perl
You shoot yourself in the foot and then decide it was so much fun that you
invent another six completely different ways to do it.


********** Perl
There are so many ways to shoot yourself in the foot that you post a query
to comp.lang.perl.misc to determine the optimal approach. After sifting
through 500 replies (which you accomplish with a short Perl script), not
to mention the cross-posts to the perl5-porters mailing list for which you
upgraded your first sifter into a package, which of course you uploaded to
CPAN for others who might have a similar problem (which, of course, is the
problem of sorting out e-mail and news, not the problem of shooting
yourself in the foot), you set to the task of simply and elegantly
shooting yourself in the foot, until you discover that, while it works
fine in most cases, NT, VMS, and various flavors of Linux, AIX, and Irix
all let you shoot you in the foot sooner than your Perl script could.


********** Perl
You shoot yourself in the foot, but nobody can understand how you did it.
Six months later, neither can you.


********** Perl
shoot foot;

Perl will automatically find a gun for you, load it if needed, and, since
you didn't specify whose foot to shoot, will default to shooting your own.


********** PHP
You shoot yourself in the foot with a gun made with pieces from 300 other
guns.


********** PHP
Three thousand people line up on your apartment's welcome mat and demand
to be shot in their feet. One by one, you oblige them, but halfway
through, the http connection times out and the crowd lynches you.


********** PL/1
Since the bullet is a different type from your foot, the bullet
automatically gets converted to another foot on arrival. It's still
difficult to walk afterwards.


********** PL/I
You discover 6,752 different guns for shooting yourself in the foot.
Before you can decide which one to use, you starve to death.


********** PostScript
foot bullets 6 locate loadgun aimgun shoot showpage


********** Prolog
You tell your program you want to be shot in the foot. The program figures
out how to do it, but the syntax doesn't allow it to explain.


********** Python
You try to shoot yourself in the foot but you just keep hitting the
whitespace between your toes.


********** Python
You shoot yourself in the foot and then brag for hours about how much more
elegantly you did it than if you had been using C or (God forbid) Perl.


********** Revelation
You'll be able to shoot yourself in the foot just as soon as you figure
out what all these bullets are for.


********** RPG
First you define your gun, bullet, and firing pin. Then, you define your
foot, toes, and toenails. Then, you open chamber and load the gun. Then,
you cock it. Now you're finally ready to shoot yourself in the foot.


********** Ruby
You shoot yourself in the foot and then have to justify it to all your
friends who are still naively using Perl.


********** Ruby
Your foot is ready to be shot in roughly five minutes, but you just can't
find anywhere to shoot it.


********** Shell scripts
You can't remember the syntax for anything so you spend five hours reading
man pages before giving up. You then shoot the computer and switch to C.


********** Shell scripts
aim -t `self --display foot` | xargs gun --shootat

You'll know it worked if your foot hurts. You'll know it didn't work if
the pipe's exit status is not zero.


********** SmallTalk
You spend so much time playing with the graphics and windowing system that
your boss shoots you in the foot, takes away your workstation, and makes
you develop in COBOL on a character terminal.


********** SmallTalk
You shoot yourself in the foot and your foot sends doesNotUnderstand: Pain
to your brain.


********** SmallTalk
You daydream repeatedly about shooting yourself in the foot.


********** SNOBOL
You grab your foot with your hand, then rewrite your hand to be a bullet.
The act of shooting the original foot then changes your hand/bullet into
yet another foot (a left foot).


********** SNOBOL
If you succeed, shoot yourself in the left foot.
If you fail, shoot yourself in the right foot.


********** SQL
SELECT @ammo:=bullet FROM gun WHERE trigger = 'PULLED';
INSERT INTO leg (foot) VALUES (@ammo);


********** troff
rmtroff -ms -Hdrwp | lpr -Pwp2 &
.*place bullet in footer .B .NR FT +3i
.in 4 .bu Shoot! .br .sp .in -4 .br .bp NR HD -2i .*


********** UNIX
% ls
foot.c foot.h foot.o toe.c toe.o
% rm * .o
rm: .o: No such file or directory
% ls
%


********** Visual BASIC
You'll shoot yourself in the foot, but you'll have so much fun doing it
that you won't care.


********** Visual BASIC
You do a Google search on how to shoot yourself in the foot using Visual
Basic. You find seventeen completely different ways to do it, none of
which are properly structured. You paste the first example into the IDE
and compile. It brushes your teeth.


********** Visual BASIC.NET
You spend a fortune on a high-powered, self-cleaning, self-aiming,
automatic handgun with unlimited ammo, only to realize it takes a year to
pull the trigger.


********** Visual FoxPro
You mock other sharpshooters for not being able to shoot both feet at
once, but when you try to do it yourself you realize that you can't
properly handle the Microsoft.gun ActiveX.


********** Windows 95
d:\setup


********** XML
You vaporize your entire lower half with a bazooka.


********** XML
You can't actually shoot yourself in the foot; all you can do is describe
the gun in painful detail.


********** Zork
>shoot self in foot
I don't see any self here.
>shoot me in foot
There is no you in the foot.
>shoot foot
I don't know which foot you're talking about.
>shoot left foot
You don't have the gun.
>get gun
You take the gun.
You're lantern just went out.
You are attacked by grues.
* * * YOU HAVE DIED * * *


********** ZZT
There is no command to do that in ZZT. You can shoot everything else,
though; or you can try to fake it somehow.

You are viewing proxied material from zzo38computer.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.