whee, i made their pointless C compile!

stupid axe ad

typedef struct {
  int girlfriend;
} holder;

typedef struct {
  holder a;
} toplevel;

typedef struct {
  int this;
} yoda;

int main() {
  holder holder = { 2 };
  yoda understand = { 2 };
  toplevel get = {holder};
  int you = 2;

  /* whee, i made this stupid code work! */
  if (you == understand.this) {
    get.a.girlfriend;
  }
  return 0;
}

#!/usr/bin/env python
class foo: girlfriend=42
class get: a=foo()
class understand: this=42
if __name__ == "__main__":
  you = 42
  if you == understand.this:
    get.a.girlfriend

Axe.py

class MisogynyEnabler:
        pass

understand, get = MisogynyEnabler(), MisogynyEnabler()

you = 1
understand.this = 1

if you == understand.this:
        try:
                get.a.girlfriend
        except AttributeError:
                raise Exception('Outdated attitudes detected')

setmetatable(_G,{__index=function()return _G end, __call=function()end})
if you == understand.this then
  get.a.girlfriend()
end

Lua won't parse the middle line without an assignment or a function call, unfortunately.

another php attempt with not-quite-right syntax but I found it funny (and this one actually executes something)

class Axe {
    public function __get($name) {
        if($name == "girlfriend") {
            echo "lol only single males know code";
        } else {
            return new Axe();
        }
    }
}

$get = new Axe(); // sadly constants can't hold objects otherwise I could get rid of the dollar.

define("you", "lolmoney");
define("understand", "lol");
define("this", "money");

if(you == understand.this) {
    $get->a->girlfriend;
}

?>

#!/usr/bin/env python
class a(object): __getattr__ = lambda s,*a,**k: s
locals().update({i:a() for i in ('you', 'understand', 'get')})

if you == understand.this:
    get.a.girlfriend

Here's my python version:

class Object():
    def __init__(self):
        self.a = self
        self.girlfriend = self
        self.this = self


def axe(you, understand, get):
    if you == understand.this:
        get.a.girlfriend

you = Object()
understand = you
get = Object()

axe(you, understand, get)

/* You "class" */

function You() {
    this.understanding = ['some-bullshit-pseudocode', 'axe-being-terrible'];
}

You.prototype.understand = function (wat) {
    return this.understanding.indexOf(wat) !== -1;
};

/* Girlfriend "class" */

function Girlfriend() {}

Girlfriend.prototype.get = function () {
    alert('lolol u smell like a 14 year-old');
};

/* Main shit */

function init() {
    var you = new You();
    var thisBullshit = 'some-bullshit-pseudocode';

    if (you.understand(thisBullshit)) {
        var girlfriend = new Girlfriend();
        girlfriend.get();
    }
}

init();

(not written by me, thank @BellendSebastian)

It is worth noting (for extreme values of "worth") that this snippet is also valid (though pointless) brainfuck syntax.

coffeescript!

you = understand: (that) => this is that
get = a: girlfriend: -> alert 'You suck Unilever!'
do get.a.girlfriend if you.understand this

I'm married. Fuck you all. totters off

#!/bin/bash

you="bleh.blah"
understand="bleh"
this="blah"
get="echo "
a="You suck,"
girlfriend=" Unilever"

if [ ${you} == "${understand}.${this}" ]; then
    ${get}${a}${girlfriend};
fi

Brainfuck:

          +++                                                                                                                                                                                                                                  
         +++++
         ++[>+
         >+++>
         +++++
         ++>++
 +++ +++ ++<<< <-]>>
>>-----------.+++++++
+++++++++++++++.++++++.<
<++.>>--.++.------------
------.++++++++.<<.>+++
++++++++++++.>+++.----
 -.+++.-------.+++++
++If++you++understand++this+;+get+a+girlfriend.
  <+++++++++++++
  +++.>----.<<+.

@sgerrand re: first ruby example, I believe idea was to make parse/compile, not to output obscenities for some ad agency. :)

PHP - Live Test 5.0.0 - 5.5.1

Issues

    try {
        if ($you = new Understand(new You())) {
            $you->get()->a()->girlFriend(new Her());
        }
    } catch ( NullBabeException $e ) {
        echo $e->getMessage();
    }

Classes

abstract class Person {
    abstract public function name();
    function __toString() {
        return $this->name();
    }
}

class Her extends Person {
    public function name() {
        return "girlFriend";
    }
}

class You extends Person {
    public function name() {
        return "you";
    }
}

class Understand {
    private $y, $i;
    function __construct(Person $y) {
        $this->y = $y;
        $this->i = "";
    }
    function a() {
        return new What($this->y, $this->i);
    }
    function get() {
        while ( $x = mt_rand(0, 5) ) {
            $this->i .= $x;
        }
        return $this;
    }
}

class What {
    private $i, $y;
    function __construct(Person $y, $i) {
        $this->i = $i;
        $this->y = $y;
    }
    function girlFriend(Person $her) {
        throw new NullBabeException(sprintf("%s is Needed ASAP Found %s issues with  %s ", 
                $her, number_format(( int ) $this->i), $this->y), E_CORE_WARNING);
    }
}

Exceptions

class NullBabeException extends Exception {
    function __construct($m) {
        parent::__construct(sprintf("<h1>%s</h1>", $m));
    }
}

#!/usr/bin/env python
import this

# ;_; http://www.youtube.com/watch?v=o9pEzgHorH0
class Person(object):
    def understand(self, concept):
        assert concept
        return concept

    def get(self):
        return self

you = Person()
girlfriend = Person()

if __name__ == '__main__':
    if you.understand(this):
        girlfriend.get()

orf's python doesn't reach the if block, thus my version:

class a: __cmp__ = lambda *a: 0
class b(object): __getattribute__ = lambda *a: b()

you = a()
understand = get = b()

if you == understand.this:
    get.a.girlfriend

Didn't actually read his before I wrote mine. That feeling when someone already had your idea... head → wall

And because I didn't like the mass definition of structs, here's my C version (for which I had to modify the syntax slightly):

int main() {
    union bar {
        void* this;
        union bar* a;
        void* girlfriend;
    } get;
    void* you = get.a = &get;
    union bar understand;
    understand.a = get.a;

    if (you == understand.this) {
        get.a->girlfriend;
    }
    return 0;
}

Only 8th grade boys like the smell of Axe. The irony is that 8th grade girls think the boys who like it are idiots. So if you want a girlfriend, you;re better off with Old Spice.

#!/usr/bin/perl

=head1 NAME

douchebag.pl - douchebaggery implemented in Perl

=head1 SYNOPSIS

    $ perl douchebag.pl

=head1 DESCRIPTION

douchebag.pl is precisely what it says on the tin.

=head1 COPYRIGHT

Copyright (C) 2013 Apreten Tiousass Wipe

douchebag.pl may be used and/or redistributed under the same terms as Perl itself.

=cut

sub get_a {
    my ($object_to_get, @args) = @_;
    if ($object_to_get eq "girlfriend") {
        return 0;
    } else {
        return 1;
    }
}

sub you_understand {
    my $subject = shift;
    return 1;
}

my $this = "perl";

if (you_understand($this)) {
    get_a("girlfriend");
}

@alexindigo:

re: first ruby example, I believe idea was to make parse/compile, not to output obscenities for some ad agency. :)

My point was that it didn't compile. 😉

jplitza: ooh, i like that one, but changing the Axe code to be less stupid is a definite no-no.

@sgerrand:

It compiled and ran successfully, both on my machine and in the REPL output you posted.

Common Lisp

* (let* ((you 1) (understand.this 1) (get.a.girlfriend "HODOR!"))
    (progn
      (defmacro custom-if (func if-form block-start result block-end)
        (list `,func `(,(cadr if-form) ,(car if-form) ,(caddr if-form)) result))
      (setf (symbol-function '==) (function =)))
    (custom-if
      if (you == understand.this) {
        get.a.girlfriend;
      }
  ))
"HODOR!"

@pranavrc All the props.

yes, I think @pranavrc wins this thread with that one, macro-to-the-max!

Instead of trying to defend original code I'll propose how it should actually look to make sense:

if (you.understand(this)){
    you.get_a_girlfriend();
}