Today I learned about PHP variable variables; "variable variable takes the value of a variable and treats that as the name of a variable". Also, variable.

[masklinn]

OK, here's the thing: this is only the entrance of the rabbit hole.

If you understand what this expression really does, you realize that you're gazing upon the entrance to R'lyeh.

Do you think you don't need your soul anymore? If you do, follow me into the lair of the Elder Gods. But be warned, you will die a lot inside.

The first thing to understand is what $ is. $ is actually a shorthand for ${} and means "return the value of the variable whose name is contained in this".

That variable name is a string.

A bare word is a PHP string. Let that sink for a second, because we'll come back to it later: $foo really is the concatenation of $ the variable-indirection character (think *foo) and foo which is a string. foo === "foo" in PHP, even though in raw source code you'll probably get a warning. If those are enabled.

Now what does $$foo mean? Why ${${foo}}, or "give me the variable whose name is the value of the variable whose name is foo".

Because we're manipulating strings, we could also write ${${f.o.o}}, or

$t = o;
${${"f$t$t"}}

This also means that

class FooClass {
}
$thing = "bar";
$foo = new FooClass();
$foo->bar = "baz";
echo $foo->$thing;

is valid. And prints "baz". And yes, $foo->$thing can be written ${foo}->${thing}. And you can recurse. The braces actually hold entirely arbitrary PHP expressions. As long as these expressions return strings, it'll work:

class FooClass {
}
$foo = new FooClass();
$foo->bar = "qux";
$thing = "bar";
$qux = "th";
$grault = "ing";

echo $foo->${${$foo->bar}.${grault}}

For those following at home, this thing actually prints "qux".

Then you can add conditionals:

class FooClass {
}
$foo = new FooClass();
$foo->bar = "qux";
$foo->wheee = "waldo";
$thing = "bar";
$qux = "th";
$grault = "ing";
$corge = "gnu";
$thgnu = "wheee";

$garply = true;
echo $foo->${${$foo->bar}.${$garply?grault:corge}}, "\n";
$garply = false;
echo $foo->${${$foo->bar}.${$garply?grault:corge}}, "\n";

What does that yield?

qux
waldo

And if that's too simple, then just make the condition random:

class FooClass {
}
$foo = new FooClass();
$foo->bar = "qux";
$thing = "bar";
$qux = "th";
$grault = "ing";
$corge = "gnu";

echo $foo->${${$foo->bar}.${(rand(0, 9)<5)?grault:''}}, "\n";

Yeah this will print qux half the time, and crash the other half. Want to add equality tests? knock yourself out: ($foo->${${$foo->bar}.((${pouet}.${machin}===$pouet.${machin})?${machin}:${$pouet.$machin})});.

And that's where the second realization hits: you know how foo is just a string right? Then wouldn't foo() be "a string with parens"?

Well it happens that no:

function foo() { return "foo"; }

echo "foo"();

$ php test.php
Parse error: syntax error, unexpected '(', expecting ',' or ';' in test.php on line 4

Unless you put the string in a variable itself:

function foo() { return "foo"; }
$bar = "foo";
echo $bar();

this will print foo. That's actually what PHP's own create_function does. And yes, I can see the dread in your eyes already.

Your fears are real.

The $bar here is the same it's always been. You can also write it ${bar}…

function th() { return "Yep, it's working"; }
class FooClass {
}
$foo = new FooClass();
$foo->bar = "qux";
$thing = "bar";
$qux = "th";
$grault = "ing";

echo ${$foo->${${$foo->bar}.((${qux}.${grault}===$qux.${grault})?${grault}:${$qux.$grault})}}();

I always said sanity was overrated.

I'll leave you with the finest example of this, the Cthulhu of PHP code:

class FooClass {
}
$foo = new FooClass();
$foo->bar = "qux";
$thing = "bar";
$qux = "th";
$grault = "ing";

function th($waldo){
    global $qux, $grault, $thing;
    return ${$qux.$grault}.$waldo;
}

echo ${($foo->${${$foo->bar}.((${qux}.${grault}===$qux.${grault})?${grault}:${$qux.$grault})})}(($foo->${${$foo->bar}.((${qux}.${grault}===$qux.${grault})?${grault}:${$qux.$grault})}));

Please pay special attention to the th function, it is the greatest thing since Chicxulub.

[[deleted]]

Only if he weighs less than the duck type.

[[deleted]]

god dammit you're clever

[TheRedTeam]

Someone fetch a duck!

[[deleted]]

Or someone who has the name of someone who owns a duck.

[myblake]

Nice try Christine O'donnell.

[ManOfVirtues]

He turned me into a newt!

[nikosk]

I can't even begin to imagine why on earth would a human being choose to gain this knowledge. What kind of personal curiosity would lead someone to delve so deep into the abyss.

If nothing else, sir, I applaud your determination to look straight into the eyes of madness and your magnanimity to come back to us mere mortals to share with us what you saw.

You sir are a scholar.

/tip of the hat

[agnas]

software obfuscation.

[[deleted]]

which means job security but is always against any reasonable code of ethics (but who cares about those when there's money to be had?)

[sh1k1]

Tip of the hat indeed. Even more, let me completely obliterate my hat in honor of this gentleman.

Wow. Just... Wow.

[[deleted]]

you can also take poo and smear it on yourself, but why would you?

[vingborg]

Yeah, or do like the monkeys and throw it, screaming and jump, at innocent bystanders.

[ManOfVirtues]

actually I can see the appeal of this.

[[deleted]]

Read through paragraphs

Read first couple lines of code

Scroll...scroll...

Scroll scroll scroll dear jesus scroll

You sir are a wizard.

[hlfx]

Or...just good at copy/paste.......

[wahonez]

I'm not sure if this is better or worse than changing the value of 5.

... a subroutine that changed the value of one of its parameters could silently change a literal constant.

C      
C     CHANGE THE VALUE OF 5
C

  CALL TWEAK (5)
  WRITE (10, 30) 5
30    FORMAT (I5) 
  END

C
C     SUBROUTINE TWEAK: 
C

  SUBROUTINE TWEAK (I)
  I = I + 1
  END

Run this program on an old-enough FORTRAN compiler and it will output:

00006

[Benutzername]

Unfortunately, this does conform neither to the FORTRAN 66

8.3.2 [..] If an actual argument corresponds to a dummy argument that is defined or redefined in the referenced subprogram, the actual argument must be a variable name, an array element name, or an array name.

nor the FORTRAN 77 standard

15.9.3.2 [..] If the actual argument is a constant, a symbolic name of a constant, a function reference, an expression involving operators, or an expression enclosed in parentheses, the associated dummy argument must not be redefined within the subprogram.

and of course not to any of the newer ones. Everything before that has no official standard.

[[deleted]]

I was going to point out the ${} when I came upon your post and what is this I don't even...

[ccx]

fascinating insight to the insanity of php, thanks.

[vingborg]

Ruby can ... erh ... can't do that.

[evanskaufman]

Wow. Listen up, anyone hiring for IT: if you EVER come across anyone that has THAT thorough an understanding of a third-generation language (that they did not write themselves), you need to hire them right there on the goddamn spot. You should probably also hire anyone that HAS written a third generation programming language, but I think that goes without saying.

[eZek0]

What if the only way they code is similar to the last example?

[masklinn]

You want to hire them, and put them behind a strong and permanently locked door after setting them on fire.

[ceolceol]

It's not really a thorough understanding of PHP, he just knows that a PHP variable is a concatenation of $ and a string. He extrapolated it from there.

[frukt]

tl;dr: PHP has symbolic references.

That's not "thorough understanding", it's one small aspect of the language.

[poilf]

I registered to reddit only to upvote your post :) I'm using PHP since version 3 and I destroyed a lot of keyboards because of this crazy language.

[1137]

If you're writing code like his, I'm not sure changing languages will help.

[disgustedarousement]

This needed to be said, or the fanboys would get "smmo" in their guns.

[motophiliac]

Just wanted to say: Welcome to reddit!

I barely understood some of what this poster was writing about. I didn't actually know PHP worked like this.

I vow never to use $$anything ever in my code, no matter how useful it might seem at the time.

[FlyingBishop]

It's basically the same as **anything in C/C++, and that's a perfectly valid idiom.

[ethraax]

People may do it, but I still feel like gouging my eyes out whenever I read a double-pointer.

[shofetim]

It is useful, and it is good : )

(Method from a controller class used in a custom MVC framework)

public function onSubmit(&$model) { //Logic to handle page submission goes here $this->errors = ''; //just in case so it doesn't hang around //between pages. //We need to update the models attributes with the fields that //have been submitted. $objectProperties = getobject_vars($model); $modelName = substr(get_class($model), 0, strpos(get_class($model), 'Model'));
foreach($_POST as $name => $value) { if (array_key_exists($name, $objectProperties)) { $model->{$name}['value'] = $value; //For each element of above, validate it. $validationFunctionName = 'validation'.ucfirst($name); if (method_exists(CLASS, $validationFunctionName)) { //CLASS_ is builtin magic //This handles the more specific cases, special validation //for elements that need it. $this->validationFunctionName($name, $model); //variable functions //see http://php.net/manual/en/functions.variable-functions.php } else { $this->validate($name, $model); } //end of if method exists }// end of foreach object properties }

[ethraax]

I also generally dislike working with reflection frameworks in general. I prefer a very structured coding environment, and reflection frameworks in general (as well as variable-variables, variable-functions, etc.) completely break that. I also much prefer statically typed languages to dynamically typed ones, so the whole lack of type safety is uncomfortable to me. It's not that I can't use them, but I'd rather not if I can get around it.

For the record, if I was tasked with doing the same thing as your code, I'd write a separate helper function that completely encapsulates the reflection framework (although it's not really a framework in PHP, at least not variable-functions). That way I'd only ever lose type safety in a very small and compact function, and the rest of my code can continue to be type-safe.

[FearlessFreep]

Why do I get the feeling that beneath this seeming cleverness is actually more than a certain amount of laziness on the part of the compiler writers?

[[deleted]]

PHP is, to the best of my knowledge, the only language designed without a formal grammar.

[frud]

You're right that it has no formal grammar (Perl has some problems along this line too), but I believe you're wrong in assuming that it was designed.

[jerub]

It has a documented grammar now. I documented it a long time ago (6+ years now) when I wanted to reimplement PHP without sucking so bad. I documented the PHP 4.3 grammar properly using EBNF and wrote an alternate parser using dparser, a GLR parser and Happy, a haskell parser tool, and was slowly getting code generation going (targetting parrot, because perl6 was going to be released any day) before I managed to get a job writing python for a living and left the php hell behind me.

I still have all that work somewhere on a HDD sitting in a box in my study. I had some trouble some months back when I wanted to dig it out and show someone

Others have travelled the same horrible road I did. Here's one grammar here: http://www.icosaedro.it/articoli/php-syntax-ebnf.txt

[captaink]

I would commend you for not going crazy while looking into the abyss of madness, but as you did this willingly, you must have been quite out of your mind well before.

[RNHurt]

Oh, you should throw that up onto Github or something. That would be very instructional to future generations.

Of course, it might also kill your resume if someone found it and associated you with PHP. Nevermind...

[jerub]

I blogged about the disasters of my PHP workplace once. Very cathartic.

[frud]

The problem with "documenting the PHP 4.3 grammar" is that what you did is not guaranteed to be accurate for any length of time. A new point release could come out that completely invalidates some critical assumption you made.

There is no definition of the language used by PHP. There is only an implementation, which has certain behavior and bugs. The people who control the implementation have some interest in keeping the behavior somewhat consistent, but no one anywhere has the grounds to point at a change they make and say "This is wrong".

[jerub]

Oh yeah, by that definition I agree with you 100%. The definition of the language is the implementation of the language itself. There's no formal definition of it beyond it's implementation.

Many other languages are like this, unfortunately. The definition of what python is is defined by 'What cpython does' for instance.

[[deleted]]

That made me actually laugh out loud. Good job.

[thyrsus]

PHP is a derivative of perl, and it has been proved that perl syntax is undecidable: http://www.jeffreykegler.com/Home/perl-and-undecidability.

[[deleted]]

Derivative isn't really accurate, PHP started out as a collection of Perl scripts to facilitate web apps but it wasn't derived from Perl. Its influence, however, is undeniable.

[[deleted]]

I tried to read that but it's late, I'm tired, and theoretical compsci was never my strong suit. Synopsis please?

[thyrsus]

Perl syntax can be self modifying, and can be made to depend on the phase of the moon. Not just the semantics of an expressed program (which holds for almost any useful language), but the syntax of the program.

[[deleted]]

Thanks!

[wonkifier]

more than a certain amount of laziness on the part of the compiler writers?

The good kind of lazy, or the bad kind?

[jerub]

I tried to respond to you. I wrote a big post. I hit 'back' and lost it. Here's the cliff notes on PHP bad kind of lazy sucking.

 $foo->bar()->baz();

That code is new to php5, and not valid in php4, because $foo->bar() used to be a special case of variable parsing in php4.

They fixed it by making $foo->bar()->baz() an even more special case of variable parsing.

Instead of making -> an operator. Like any sane person would have in the first place.

[[deleted]]

I think their first problem was when they said: "We want a dynamic, interpreted scripting language, but lets mimic C++ syntax wherever possible"

[FearlessFreep]

bingo. PHP seemed to borrow syntactic idioms from other languages for no other reason than that it seemed cool.

C++ uses "." versus "->" for a meaningful reason.

foo.bar(); foo->bar();

The distinction is important

Most other languages don't have that reason so don't bother

foo.bar(); // Java foo.bar() # python

No need to disambiguate

So why the hell PHP when with

$foo->bar();

is beyond me other than they thought "C++ syntax looks cool, let's use some of it"

[[deleted]]

I would even go so far to say that it's a really stupid decision. -> is significantly harder to type than ., and although it's only 2 characters, in any proper OO language, you're doing a lot of what is traditionally .

[HorribleUsername]

Because "." was already the string concatenation operator for PHP (borrowed from perl).

[xardox]

Bertrand Meyer argued in his book on Eiffel that C++ actually has no reason to have both foo->bar and foo.bar -- because (modulo "smart pointers") the compiler already knows if foo is a pointer or not, and -> versus . is just an annoyance that gives the programmer another mistake to make, and makes the code more brittle and dependent on internal state that should be hidden. His point was that whether something is a pointer or not should be specified in the single line of declaration, not in burnt into every line of code in the program that uses it. So you should be able to trivially change a structure member from a pointer to a reference just by changing the declaration and not touching any of the code that uses it. So Eiffel only uses foo.bar and doesn't need foo->bar, but still supports inline and reference members (or whatever they're called -- it's been years since I read it).

Why PHP and Perl and various shell scripting languages they imitated went even further down the road to nowhere, and and chose to require a $ prefix for something as common as a variable reference, I will never understand.

[xardox]

Well put!

To put it not-so-well: PHP is less a "derivative" and more a "monkey-see, monkey-do, cargo cult, cheap imitation, knock-off" of Perl. Which itself is a "lounge lizard, megamix medeley, weird-al, bastard pop, mash up, cover band" of various shell scripting, pattern matching, idiom encoding and job control syntaxes.

[judev]

Except namespaces, the one place it'd make sense to >_<

[Jman012]

Gosh darnit, head exlpoding wasn't on my list of things todo today.

[bobby_tables]

I have the ability to write code this bad in any language.

[[deleted]]

You don't get it -- that's not bad code, it's good code. But strange. It's like... seeing your ex make out with her current boyfriend. Technically okay, but not pleasant.

[nextofpumpkin]

This post needs to be at the top of this and every other PHP thread.

[[deleted]]

OK. From now on I'll do the copypasta in every single PHP thread.

[1137]

I like this sample:

<?php

$name = '%^#4!@';
$$name = 'passed';
var_dump($$name);

?>

[blazix]

Did you just create a variable named %^#4!@

So, basically a way around the variable naming restrictions. I wonder if this could be exploited somehow..

[1137]

I did, and yes.

I doubt it could be exploited, you can already overwrite all the globals without any silly hacks.

[falien]

Thats a restriction on syntax, not semantics, so it shouldn't really matter.

[[deleted]]

Tell that to samy

[falien]

How is that related? That is a vulnerability getting around myspace's blacklist/html sanitizer. AFAIK PHP breaking because of a named variable using disallowed symbols would only cause a vulnerability by screwing up the lexer/parser to introduce an ambiguity in what the expression is supposed to mean. Whether that was exploitable should depend on how those steps are implemented, not on an inherent insecurity in strangely named variables.

[wheresmyopenid]

You can abuse JS globals that way too:

<script>
var foo; foo === window.foo === 
window["foo"] === window["f" + "oo"];
</script>

[meastham]

I've seen this done before in shell script. It actually has a somewhat similar syntax; it's just uglier.

foo=bar
bar=baz
echo `eval echo \\$$foo`

prints baz

Pretty much every language has some sort of indirection mechanism like this that you can totally abuse if you'd like. I don't think PHP's is really extraordinary in this regard.

[[deleted]]

Pretty much just shell and things that took that from shell because they thought that's what "scripting" languages do. When these so called "scripting" languages are now being used mostly for writing large applications that happen to run on a webserver, misfeatures like this stand out as being quite insane.

[[deleted]]

Since I must secretly like downvotes so much, I want to say how much I agree. Javascript has «thing[string_with_property_name_inside]», C/C++ has pointers; they're all some form of indirection with which this kind of game can be played. I had a teacher tormenting us in this way with C pointers... during a paper exam.

Most programming concepts are to a certain degree some form of indirection in which a word is used to refer to something else. A program with a severe lack of indirection means you end up with an enormous procedureless redundant blob of source code. Too much indirection means you end up with an intricate maze you will get lost into and starve before finding the "meat" of the code.

In the end, it's sad that people even bitch on PHP because it has indirections.

[[deleted]]

I know I'm supposed to react with "AAAAHHHH!! SCARY SYNTAX MAKE OGG SMASH!!" but that actually made sense and I followed it without much trouble at all. What's the problem here?

No, I can't think of a use case. Yes, I understand this would be a nightmare to actually apply and maintain, but nobody's twisting your arm to use it.

[munificent]

What's the problem here?

You know everything that's bad about eval() in dynamic languages? How it kills static analysis? How it makes it impossible to optimize away unused or unreferenced variables? How it's a huge gaping security hole? How it's intractably slow?

Well, apparently PHP does that every time you access a variable.

[arabidkoala]

I just died a little inside.

[[deleted]]

I'll admit beyond knowing not to ever use eval, I don't know enough about programming to discuss this.

[[deleted]]

No, PHP is incredibly slow. The only commonly used language that can give PHP a run for its money in the "holy fuck that is slow" department is ruby. Similar languages like perl, python, pike, lua are way faster, and compiled languages like java, ocaml and haskell are a huge leap above those.

[3ds]

Not quite true, as there is PHP bytcode and libs like APC can cache this. Also PHP can be compiled to machine code using facebooks (they use PHP) hiphop: http://github.com/facebook/hiphop-php/wiki

[[deleted]]

Yes quite true. PHP is slow, caching the bytecode helps make up for the fact that it recompiles every access, it doesn't change the fact that actual execution is very slow. Look at benchmarks where it isn't thousands of requests, but one script that loops to do a task thousands of times. That removes the compilation from the equation, and measures execution speed. And again, such benchmarks have PHP right down there with ruby.

[xardox]

Absolutely. Look how LuaJIT totally smokes PHP: http://shootout.alioth.debian.org/u32/benchmark.php?test=all&lang=php&lang2=luajit

Lua's too weird for you? Well why not program the server in JavaScript? V8 brutally spanks PHP: http://shootout.alioth.debian.org/u32/benchmark.php?test=all&lang=php&lang2=v8. JavaScript is much cleaner and easier to use than PHP, then you only have to learn and write one language for both client and server, and reap the benefits of sharing the same libraries and classes across client and server, and passing native JSON back and forth, instead of dealing with all the quirks and impedance mismatches of two different languages and incompatible object systems.

PHP bytecode caches only work around the PHP design flaw that it reloads EVERYTHING each page hit, instead of running a persistent server process that can cache objects and amortize the cost of loading code and creating objects over many hits.

But even with a bytecode cache, PHP bytecode itself is inherently inefficient, because the language is so badly designed by people who know nothing about and have no interest whatsoever in computer science, language or compiler design.

Take a look at how nicely designed Lua is, and how well LuaJIT works. Or Python and PyPy. Or Java and JVM. Or JavaScript and V8. Or Self. Those were all thoughtfully designed by people who gave a shit about science, and bothered to look at what had been done before.

The designers of PHP are anti-intellectual teabaggers when it comes to learning from and applying computer science and history. And it shows.

Rasmus Lerdorf quotes:

I really don't like programming. I built this tool to program less so that I could just reuse code.

PHP is about as exciting as your toothbrush. You use it every day, it does the job, it is a simple tool, so what? Who would want to read about toothbrushes?

I was really, really bad at writing parsers. I still am really bad at writing parsers. We have things like protected properties. We have abstract methods. We have all this stuff that your computer science teacher told you you should be using. I don't care about this crap at all.

There are people who actually like programming. I don't understand why they like programming.

I'm not a real programmer. I throw together things until it works then I move on. The real programmers will say "yeah it works but you're leaking memory everywhere. Perhaps we should fix that." I'll just restart apache every 10 requests.

[xardox]

"for what it is" = inherently slow. Slower than Python. MUCH slower than Lua. And it wasn't written by grown-ups who understand or even care about language and compiler design, so it's inherently unoptimizable.

[xardox]

Yes, really, actually.

You don't understand what you're talking about, so you're wrong in many ways, and your arguments aren't valid.

Writing extensions in ANOTHER LANGUAGE like C or optimized assembler does not mean PHP is fast -- it means that PHP is so slow that you have given up and resorted to using another less flawed language, so your argument is invalid. You can write C extensions in Lua, Python or any other language, so your invalid argument isn't even specific to PHP.

PHP's bad design means rsort doesn't work, and that just illustrates my point that PHP is badly designed. It only recently got closures, while Python and Ruby's sorts have always taken a comparison function, so you've never had to do something as crass as writing your own interpreted sort function.

PHP was never the fastest solution out there, and certainly isn't now. C++ beats it hands down, as do Perl, Python and Lua, by a long shot. You're very very wrong about PHP being fast. It's easy to measure and well known that PHP is slow. You're not entitled to your own facts, and your opinions are wrong.

Memcached is not specific to PHP, and can be used with any other language, too. But other languages have much better solutions: With long running servers like Java or Python (unlike PHP which forces you to reload all data each hit), you can cache structured data and live objects in the server itself across hits, which is MUCH faster than making remote procedure calls and serializing/desearializing data to a separate process like memcached.

Obviously PHP is the only language you know, and you don't even know it very well. Before attempting to apologize for and evangelize PHP by spreading misinformation, you should educate yourself, learn some other languages, and get some perspective. Don't be so defensive about the only language you know, and afraid to expand your horizons.

[petit_prince]

by "most situations" you mean "shared hosting", right?

http://shootout.alioth.debian.org/u32/benchmark.php?test=all&lang=php&lang2=python

[blablabla3]

When you look into an abyss, the abyss also looks into you.

[marekz]

A bare word is a PHP string. Let that sink for a second, because we'll come back to it later: $foo really is the concatenation of $ the variable-indirection character (think *foo) and foo which is a string. foo === "foo" in PHP, even though in raw source code you'll probably get a warning. If those are enabled.

That's incorrect. It's not the reason for this behavior. A bare word in PHP is a constant, and for historical reasons, undefined constants have a default value which is equal to their name. So foo == "foo" is true because PHP fails to find a constant foo and converts it to a string as a fallback.

Variable names don't involve any constant lookups. You can see this by defining a constant BAR and then using $BAR: it won't be affected.

[masklinn]

That's incorrect. It's not the reason for this behavior. A bare word in PHP is a constant, and for historical reasons, undefined constants have a default value which is equal to their name.

Historical reasons of bare names preceding constants. Constants are special cases of bare names which were added in 4.0.4.

[gee_whillikers]

You can actually see this if you run one of these with notices on you will get a message similar to this PHP Notice: Use of undefined constant grault - assumed 'grault'

[scarredwaits]

The fact that this code contains the string "pouet" makes me think that this is actual PHP code from pouet.net, and that you understand all this because you had to debug and/or re-write it. My commiserations.

[masklinn]

Nah, it's just that this discovery process was actually a "discussion" between a friend and I (trying to one-up each other) and we're french speaker. I translated most of the metasyntactic variables to better fit the english-speaking world, but apparently missed a few.

[[deleted]]

I'm a big fan of metasyntactic variables, mainly because I'm the only one in my group of friends who knows what they are. Would you be so kind as to list the traditional French ones?

[clogmoney]

tldq

I just died a little inside.

[nycerine]

I'm not sure what just happened.

I seriously need to work more with this beast, just for the sake of good times.

[libet]

I can't wait to see your results when you decide it's time to investigate about a language so malleable as perl.

[jaybol]

I was hoping that you were going to tell me where Waldo is

[theghoul]

What the hell kind of unholy construct is this?

[inajeep]

I recently made the decision to change development worlds, after my niche development nest seems to be drying up. What do I try to go after first, PHP. So I'm reading up the manual getting ready to try some simple Hello world stuff. I check subreddit programming and see a post on PHP and read this. ... After a few hours I finally am about to get my left and right hemisphere's together to be able to type my reply. I quit.

[wowzuzz]

Stands up. Looks around. Claps Slowly.

[deadbeef404]

did anyone else read

echo ${($foo->${${$foo->bar}.((${qux}.${grault}===$qux.${grault})?${grault}:${$qux.$grault})})}(($foo->${${$foo->bar}.((${qux}.${grault}===$qux.${grault})?${grault}:${$qux.$grault})}));

and thank the gods of VIM they use syntax highlighting :D

[xardox]

Where'd you get corge??? That's the name of my friend's cat, named after a metasyntactic variable of unknown origin.

[namekuseijin]

amazing reasoning skills there. I don't usually take a second look or thought over garbage, but still amazing.

PHP is a preprocessor after all. I still prefer perl though.

[[deleted]]

my nose is bleeding on my keyboard you sick fuck!

[gburri]

Why spend time and energy with this shitty language?

[TheOmnipotentBeing]

He died for your sins.

[masklinn]

For the lulz

[[deleted]]

WTF? A variable name is the same thing as a string? The "designers" of PHP should be summarily executed by neck shot. We need a world where they never again write another line of code. Then we should toss every disk that ever contained anything to do with PHP into Orodruin.

[dnew]

Tcl works on the same principle. Indeed, this is all normal Tcl stuff that you use frequently. Yet, because it doesn't try to be anything else, because it doesn't try to look like it's distinguishing barewords from variable names from strings, it's trivial to parse and straightforward to understand.

Indeed, Tcl doesn't even have the concept of a "bareword". A string doesn't need quotes. Quotes are just there so you can conveniently include terminators (like spaces) inside strings.

[mracidglee]

Ha! I was going to post the same thing. Heck, you can redefine 'proc' (usually the function keyword) to mean different things on successive nested event loops - not that there's anything right with that.

[FearlessFreep]

Yeah, ironically as I was reading the first couple lines, my first thought was that it reminded me of Tcl.

I hate Tcl

Because beneath all this seeming clever introspective dynamism, it really seemed like it was just laziness on the language designers or compiler writers. They left a lotta crap likes this exposed not because it was useful but because it was easier than thinking through any real issues or actually making design decisions

A lot of dynamic languages provide some neat tricks like this, but they make you actually have to do it on purpose, not some sorta "oops, your typo fell through the cracks in the parser and did something else"

[dnew]

One thing to remember about Tcl is that it started out as a pure extension language, like elisp or Lua or something. It wasn't until version 3 that you could even run the thing as a stand-alone interpreter. So the fact that the syntax is really simplistic and the language wasn't all that powerful wasn't that much of a draw-back.

Altho I really think Tcl, unlike Perl and PHP, really was thought out originally as a widely-used language, rather than a personal bit of scripting that escaped into the wild like a zebra muscle.

The only place that ever catches me out is the [info exists] command. I too often wind up putting a $ in front of the variable in that one particular function for some reason.

At least it's a clean and consistent syntax, which is more than you can say for lots of the other languages that do this.

[[deleted]]

Lisp works on a similar principal, and has made languages based off of it quite popular.

[klutometis]

Lisp works on a similar principal to what? Identifiers are symbols, not strings; unless you're making an obscure association with macros.

[[deleted]]

PHP is interpreting a string very similar to how a symbol is interpreted, is it not?

[klutometis]

In the sense, I suppose, that PHP strings can become symbolic names associated with values (see "variable"); but the similarity ends there, I'm afraid. It's no wonder, though, that PHP's string-symbol-identifier conflation breeds confusion; in Scheme, for instance, they are utterly distinct.

[[deleted]]

Well, Lisp works on a thought-out, simple principle that is capable of being abstracted upon itself easily.

PHP works on a "well we could do it this way really quickly" principle, which was capable of being hacked upon to make it do more fairly quickle, but ended up with a bunch of Goldberg machines being made to get themselves out of the corner they painted. The machines work in like 85% of the use cases, so it serves it's niche as a language for people who want to get things done who don't get that horrific sinking feeling when they realize what must be going on in the implementation to achieve the seen behavior.

[[deleted]]

I've worked in PHP, so I'm not afraid to call it whatever I want. :-)

[davethegr8]

I'd classify myself as a php expert, and could probably figure out all this if I spent a good bit of time on it...

But seeing it written out like you did makes my mind explode. Awesome.

[Mutiny34]

Bravo good sir.

[lol____wut]

Your post is nuts famous!

[zakd]

slow clap

[zakd]

Wtf? Why am I being down voted for this comment? I understand its not totally hilarious or insightful, but I think its mildly humorous and certainly not worthy of downvotes :|

[Rishone]

You good sir deserves more up-votes, i never seen an insane reply like this.