How to shoot yourself in the foot in any programming language | Hacker News Reader

How to shoot yourself in the foot in any programming language

fullduplex.org

52 pointsAndrewDucker35 comments

Haskell - You try to shoot yourself in the foot, but instead, a new foot appears in front of you that is identical to your own except that it has a bullet in it. Oh, and it's wrapped inside a burrito for some reason...

gun `shoot` foot But there’s a side effect, so it doesn’t work. Try to use the state monad… get confused, so you write your own shooting monad, and then come up with this code:

gun >= id foot

but this puts your gun in your foot. Then you write your data types data Space = Empty | Gun| Foot deriving (Show, Eq, Ord)

–if you’re right-handed, this code should work shootFoot = foldr (shoot bullet) Empty $ enumFromTo Gun Foot

–For southpaws foldl’ (shoot bullet) Empty $ enumFromTo gun foot

Excellent. I also would have accepted

    Violence.hs:5:35:
        No instance for (Shootable BodyPart) arising from a use of 'shoot'
        Possible fix: add an instance declaration for (Shootable BodyPart)
        In the expression: shoot $ user ^. foot
        In an equation for 'violence': violence user = shoot $ user ^. foot

You should abstract this; you realize bullets are group actions on the set of feet, right?

Edit: Sorry, not group actions, monoid actions. Group actions would mean there was some kind of inverse bullet. Also note that bullets aren't commutative.

You try to shoot yourself in the foot, but you realize the bullets are of the wrong type. After sawing the bullets to the right size, you attempt to lift your gun, but it takes too much space and blows up.

Haskell—after spending a great deal of effort setting up various layers of foot-shooting-proof prophylactics you find yourself in a situation where the only reasonable way to start walking is to go ahead and shoot yourself in the foot anyway. You do so and are able to basically walk except somewhat awkwardly thanks to your now bleeding foot.

Then you go online and are helpfully told that what you really needed was a an abstract shoe, that bleeding feet are prone to infection and impurities, and if you had only read this one research paper there's a 2-liner in there showing you how to program Usain Bolt with wings.

Yikes. If you want to "improve" on a perfectly adequate joke, it helps to have tried the language before.

Oh, I use it to build production code daily and actually quite love the language.

Befunge [http://en.wikipedia.org/wiki/Befunge]

      _  _  _ .'`;
    _(_)(_)(_)|  |
   (_)        `--'
    .-'``````---.          ,-.______________,=========,
    |            ;        [|  )_____________)#######((_
    `'-......---''         /===============.-.___,--" _\
    .-'``'.               "-._,__,__[JW]____\########/
    |    (                          \ (  )) )####O##(
    |     \                          \ \___/,.#######\
    :      \                          `===="  \#######\
    :       `.                                 \#######\
    :         \                                 )##O####|
    |          |                                )####__,"
     \         /                                `--""
      `'-...-'`

The last version I saw, probably 20 years ago, had the APL version something like

"Somewhere a gun goes off and hole appears in your foot, but you don't remember enough linear algebra to figure out how this happened."

Erlang:

* You send a message to your hand process to shoot yourself in the foot.

* Hand process sends a message to the gun process.

* Gun process sends a message to the primer process.

* Primer process sends a message to the foot process, using the bullet to contain state.

* Bullet state is passed to the foot process,

* Foot process creates a copy of your foot that contains a hole, and sends a message to the leg process indicating that it should accept the replacement foot...

I don't like the CSS one.

Here are a few ideas:

You take the gun to a smaller room and it disappears.

You're left-handed but the gun doesn't support left-hand prefixed properties.

The gun is too big in your right hand but too small in your left hand.

You take the gun to a different range and your beautiful, well designed gun is suddenly too ugly to behold.

You miss your foot because you're standing in line next to a guy that's floating.

You try to center your gun over your foot but can only center bullets.

>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.

Anyone have a modern version for this?

Well, first you have to pick a gun framework, then figure out how to $elect your gun in it. Then you update the Gun model and set a callback onFire, and wonder what the hell happened. Later, the callback shoots you in the back of the head.

My take:

> Javascript

> There're so many guns to choose from that when you finally choose one, it's suddenly no longer cool to shoot yourself with it so you look for another one.

ps. I love Javascript :)

My version of this: "You have the gun, but you never fire it because you can't decide on accessories."

    self.shoot(function() {
        holster.unclip(function() {
            gun.remove(function() {
                safety.disable(function() {
                    trigger.pull(function() {
                        // help I'm trapped in a callback factory
                    });
                });
            });
        });
    });

I was thinking along the lines of, "After building a suitable gun, you find it doesn't fire because the bullets are of the wrong type."

Or better yet, wrong scope

You have a solution, but you worry that it isn't web-scale.

You try to shoot yourself in the foot, but somebody has monkey-patched your gun so that instead of bullets, a little flag comes out that says "Bang!".

Along the same lines: "If programming languages were cars"

http://users.cms.caltech.edu/~mvanier/hacking/rants/cars.htm...

Okay, I'll admit that the whitespace crack at the end was pretty funny.

They are all pretty funny, at least when I can actually understand the inside joke...

Objective C/Cocoa: Simply use the built-in API:

[[[FSGun alloc] initWithGunType: FSGunTypeShotgun] shootBodyPart: FSBodyPartFoot side: FSBodyPartFootSideLeft onPerson: self]

Some classics there (there have been versions of this knocking around since at least the mid-90s and probably much earlier) but it's great to see some new ones.

I first encountered it in 1991, I think. Probably on the Monochrome BBS.

I usually liken PHP to an AK-47.

Its rickety, it bends and moves when you use it, but no matter what it just keeps working. Although there have been new platforms to come out with superior technology, none can match its simplicity and ease of use, and because of this it has been used in more instances than any other. Hell, even a kid can operate it.

my favorite is unix way of shooting in the foot.

That and Perl.

Mine is the 370 JCL, because of the surreal but instantly familiar "three years later, your foot comes back deep-fried".

The only problem is that neither i nor anybody else alive today has any idea what 370 JCL is. Can someone repurpose this to be about the Cloud?

Thankfully, I don't have to deal with it any more, but Z/OS JCL is dealt with on a daily basis by people sitting within five feet of me.

They have five feet? Sounds like someone ran the batch too many times.

Go: "Don't share a bullet by shooting, shoot yourself by sharing a bullet."

Reply on news.ycombinator.com