function test_nine() {
	$$"9" = 22;
}

fails to parse.
(which is good, I suppose)

This passes:

function test_nine() {
	$n = 9;
	$$n = 22;
	$this->assertEqual($$n, 22);
}

-Andy Friesen,
of giant-communist-robots.com.

…it sets $whatever on my outer instanced class.

Here’s some illustrative code:

<?
    class Inner_Static {
        function burrito() {
            $this->_member = ‘A keyboard. How quaint.’;
        }
    }

    class Outer_Instance {
        function taco() {
            Inner_Static::burrito();
        }
    }

    $my_guy = new Outer_Instance();
    $my_guy->taco();

    print ‘$my_guy->_member: ‘ . $my_guy->_member; 

This boggles my mind a bit. Tracking it down cost me a bit of time. Is there actually a sane use for this little tidbit, or am I justified in thinking that a good language would warn you that scope shenanigans are going on here?

A need for a simple one-off occurred Monday evening at work. Some non-engineer coworkers needed to be shown how to make some non-Latin-1 text into html entities.

Basically, they needed a 5 line php script.

Right before sending them to any number of sites that already do this 5-line operation, I decide: what the hell, I’ll just make one of my own. And so, that night after unwinding, I did.

Here’s my HTML Entitizer. Suitable for all your HTML entitizing needs, large or small!

PHP in Escape from L.A.(jokesfornerds)

One of the reasons PHP is so popular is the fact that it’s got so many handy little functions. In this case, htmlentities() is the blade of PHP’s swiss army knife that we’re using. Of course, indiscriminate use of functions like this cause problems like double-escaped characters (&) showing up in databases.

PHP’s solution to this sort of thing is generally to throw new corkscrews and toothpicks onto it’s ever-growing pile of tools on it’s knife. If you look at the documentation page for htmlentities(), you can see that as of version 5.2.3 of PHP, another optional parameter was added: double_encode. Which will

Getting the right escape order can be hard, especially for novices or small teams inheriting code from other small teams. To date I don’t think I’ve inherited work on a webapp whose database wasn’t littered with extraneous &’s and rogue \\’s. It’s only by virtue of verge-rpg.com having a single developer who is really, really annoyed by this problem the the point of neuroticism that & never appears in the database except in posts that actually wanted to display &.

Although even this level of OCD-database-cleansing didn’t prevent escaping-related errors on the first go-round.

Teh (sic) Implementation.

So, the only time-consuming part of getting this script into my wordpress site (other than me taking a bloody half hour to blog about a 2-minute job) was convincing wordpress that it should allow <?php fragments into my posts.

Luckily, other people before me have wanted this very thing. WordPress’s biggest strength is again one of PHP’s: if you want it, it’s already been made for you. In this case the Exec-PHP module will let admin-level users of your blog post for-reals, actual PHP into your posts! You’d better hope your admins don’t have their accounts compromised! (…one moment. Changing my password.)

In PHP’s case, the code that you want that’ already been written for you is in every single function’s talkback thread. These functions may not be hyper-optimized or the best solution for any given problem, but they generally are what you want to prove a point. You scan the docs, you grab the code, you put it in your site, and you move on to the next problem in your own app.

Quick and dirty, the way PHP likes it.

For the curious, here’s the solution I spat out (copy included):

<h1>Escape html</h1>
<p>This is a simple script to give the escaped codes for some html. Useful
for making foreign languages play nice with html, regardless of how the
server handles string encoding.</p>
<?
if( isset($_POST['escape_me']) ) {
echo('<h2>Your escaped html</h2><div'.
     'style="background-color: #ddd; padding: 8px;">');
echo(str_replace('&','&amp;',htmlentities(stripslashes($_POST['escape_me']),
     ENT_NOQUOTES,'UTF-8')));
echo( '</div>' );
}
?>
<form action='/html-entitizer/' method='POST'>
Text to escape:
<textarea name='escape_me' style='width: 550px; height: 200px;'></textarea>
<input type='submit' value='Create my html entities'>
</form>

(weird formatting so it doesn’t run off the side of the screen; I don’t actually code like that. Mostly. ;)

Coda

It is of note that this tiny amount of effort got me two really sincere “thank yous” from the non-engineers. It’s important to note that things that are mindlessly trivial to a programmer can be tedious tasks to someone without the power to bully the computer into doing labor for them. One of the guys, a computer saavy guy who had access to lists of what each escaped character translated to, insisted that he’d just search/replace the offensive characters by hand.

Ostensibly, this was offered to save me work.

How much time did my 2 minutes of code save him?

(Don’t forget a google for “html entity converter” would’ve saved even that, had I cared to not make the tiny toy script of my own. I’ll ramble on about re-using other people’s work more later, but it’s key to remember even what little work I did end up doing was extraneous and largely an exercise in vanity.)

Split Tests are a very powerful way to determine if a thing you are doing is in your best interest or not. If you aren’t familiar with A/B tests, the very high level is that you show half of your users one thing, half another thing, and you compare the results of each set of users.

Humanity

One of the more mundane, human problems you can run into as an engineer is tiredness. Tunnel vision sets in, and you focus on specific tasks. If you’re solving a complex math problem, you make an arithmetic error. If you’re a coder not using TDD, often you’re running into syntax errors or the like.

These things happen.

Process

At IMVU, we deploy code fifty times a day. The code you just wrote goes out to the production cluster without waiting for QE people to sign off on it, or for your manager to approve it.

Engineering under TDD acts like a blanket to shield you from a lot of problems. You know from the get-go if you broke something in a more interesting way (assuming said interesting way was protected by a test). The tests exist to protect you before you get near the production systems. A failed test on your buildbot is a good thing, because that’s a broken thing your customers never had to deal with. As someone who had jobs where he was tacitly encouraged to code untested fixes on the fly on the production machines in other jobs, this is a godlike boon.

However, things go wrong, and sandboxes and production environments still can disagree! This is why the final step of pushing code live to a production server is always, always, always verify your change manually out in the live website.

And if it’s not verified (or if your change breaks things in very unexpected ways, causing die spikes or high database load or the such), to revert to a previous known good state and investigate further.

Moral

Now that all of the background for tonight is set up, I’ll skip the actual stupidity, and jump straight to the conclusion:

When testing a feature wrapped in a spiffy-keen augmentation of an experiment system live, please remember to take into account that you have a 50% chance to land in the “nothing happens” side of the experiment. This will probably save you a lot of trouble.

It was a pleasant surprise when I looked up to see a wonderful forest around me. I’d just been staring at this one tree over here.

The other kind of Restful

The fun part is my team’s Quality Engineer, who was familiar with this feature and had tested it in production live before, was also up working. He didn’t catch the obvious either, because it was so obvious.

Say a human has a 10% chance of making a mistake/forgetting something obvious. Say he’s got a pairing partner with the same ratio. Assuming an ideal world, you’ve reduced your net error ratio to 1% by having another dude on the case with you. Yay pairing!

If both dudes are tired, their error rates go up, and even pairing, you still have a higher chance of fucking something up. Boo tired!

…Perhaps there’s a better moral than the one listed above hidden in here?

Back in 2004 I wrote

Nobody understood this properly when I wrote it originally, so then in my comments I wrote some psuedocode to explain the logic flow of that sentence and it cleared it up.

(Aside: Comparison of the previous two sentences shows that in five years I’ve not stopped ending my sentence in prepositions. I, like most of you, run english in quirks mode.)

The conclusion

Code is far less ambiguous than english because people are not used to strictly interpreting english. (The previous sentence implies that math majors are not people; I’m willing to defend that.)

So I revisited the psuedocode in the post and found it amazingly brittle and unreusable! And there was a bug in the final clause. Oh, the perils of not test-driving your emotionally charged statements. So, in the interests of avoiding arrogance-rot, I refactored and generalized it a bit!

An Exemption

I’m not sure if I believe this anymore at all. It’s been a while since I re-evaluated my political stances. I think I’ve gone from a hardline libertarian to a broken, beaten, shattered shell of a libertarian.

So, the contentious arguments here aren’t so applicable anymore. I just wanted to point illustrate that the opening statement is hyper-charged and people fail to interpret it correctly, whereas the code is much easier to interpret to those who have been trained in the Way of the Computer.

/// Takes a Person object, and sets it's member variables accordingly for
/// it's 1::1 relation with Grue in respect to Grue's respect for that
/// Person.
///
/// @param you The person to judge.
/// @see Person::ProcessReaction()
/// @see _BattlegroundStateCalculator()
/// @todo implement all of the various non-election-related ways a person
///       can be a total douche in my eyes.
/// @todo exemption clauses for 'lesser of two evils'?
/// @todo set dead_to_me flag if '3rd party'/'wasted vote' argument comes
///       up.
void Grue::CalculateRespect( Person you )
{

    PoliticalOffice* p_office;
    p_office = PoliticalService.getCurrentOfficeUpForGrabs();

    if(
        // if you think the current system is Shitty...
        you.opinion_on_US_govt == E_FUNDAMENTALLY_FLAWED &&

        // ...and if you *dont* live in a battleground state...
        // (calls a helper function)
        !_BattlegroundStateCalculator(you.state_of_residence) &&

        (
          you.vote[TimeService.getCurYear()][p_office] ==
              PoliticalService.getCandidateForOffice(p_office,'GOP')
          ||
          you.vote[TimeService.getCurYear()][p_office] ==
              PoliticalService.getCandidateForOffice(p_office,'DNC')
        )
    ) {
        you.hypocrite = true;
        you.sentient = false;

        // set all possible forms of respect as false.
        for( int i=0; i<MAX_RESPECT; i++ )
            you.grue_respect[i] = false;
    }
    else // only do this if they were not deemed Horrible.
    {

        // Now see if the person was offended by the process we just judged
        // them against...
        you.ProcessReaction();

        // if somehow you're offended during this evaluation for any
        // reason, mainly for not understanding the hierarchy of judgement,
        // then you're dumbstuffs for being offended, but I cannot judge
        // you otherwise.
        if( you.offended_flag )
        {
            you.grue_respect[i] = REPECT_INTELLECTUALLY;
        }
    }
} //Grue::CalculateRespect()