"No, the problem results because lowercase i (in most languages) and uppercase I (in most languages) are not actually considered to be the upper/lower variant of the same letter in Turkish. In Turkish, the undotted ı is the lowercase of I, and the dotted İ is the uppercase of i. If you have a class named Image, it will break if the locale is changed to turkish because class_exists() function uses zend_str_tolower(), and changes the case on all classes, because they are supposed to be case insensitive. Someone else above explained it very well:
"class_exists() function uses zend_str_tolower(). zend_str_tolower() uses zend_tolower(). zend_tolower() uses _tolower_l() on Windows and tolower() on other oses. _tolower_l() is not locale aware. tolower() is LC_CTYPE aware."
Edit: Someone else later said the following (I'm wondering if it's true):
"This, practically, can't be fixed. Mainly because there's no way to know if 'I' is uppercase of 'i' or 'ı' since there's not a separate place for Turkish 'I' in code tables. The same holds for 'i' (can't be known if it's lowercase of 'I' or 'İ'). I told 2 years ago and will say it again: PHP should provide a way to turn off case-insensitive function/class name lookup. No good programmer uses this Basic language feature since identifiers are case-sensitive in all real languages like Python, Ruby, C#, Java."
Maybe it breaks if you embed unicode strings or something. What do other languages do?
Based on the behavior of this bug, it appears that the way PHP handles this case insensitivity is that it just lowercases all class and function names before resolving them. And this bug in particular shows up for Turkish because 'i' is not the lowercase equivalent of 'I'.
Pretty much all other modern languages are case sensitive, so I'd be surprised to find this issue elsewhere.
Obviously, case-insensitive identifiers are a bad idea, but PHP is stuck with them at this point.
Or anywhere for that matter?
There is no "they" in this equation. There is no person who should be held more accountable than you or I for fixing this problem.
The choices are simple:
1) Fix the problem
2) Find a work around
3) Don't use PHP
What's that? There is a lot of open source software that you wanted to use for free that's written in PHP that does just what you need except for this tiny little trivial thing that should be easy to fix? Well too bad!
Trade off the cost of fixing it against the cost of rewriting the big, free, open source package that's written in PHP you wanted to use, in the programming language of your choice, and stop complaining.
PHP is crap. Not even classical ASP had such bugs and it was perfectly passing the Turkey test (http://www.codinghorror.com/blog/2008/03/whats-wrong-with-tu...) and Unicode supporting languages didn't have such a bug. E.g. Java, Python.
PHP is crap. This bug is clearly a WONTFIX, it's been 10 years since it is reported. I remember this bug when I was 14, thank God I moved on to other languages afterwards.
edit: not trolling, just curious. What drives people to complain about specific, well-defined open source bugs without any effort to fix it? I understand hard-to-nail down issues like user experience, but this shouldn't be that hard to plan out and fix independently.
If there are viable alternative projects which are more responsive to bug reports, that is more promising for the future - if a second bug I see is reasonably likely to be fixed in the future, I can feel more confident basing my own code on it.
People spend months and years writing apps on top of things like PHP and once they have the code they don't necessarily have a lot of choice. At that point maybe you fix the bugs in your dependencies rather than rewrite your own app. But when you have a choice, you don't adopt a tool which is going to leave you with this much technical liability.
This is offered peacefully in an attempt to explain the question which seems to confuse you.
But come on. This language is complete crap. Code spontaneously fails depending on the locale? And the bug has been open for ten years and still is not fixed? And this is only one bizarre and inexplicable bug out of hundreds, maybe thousands, of bizarre and inexplicable bugs in PHP.
This language isn't defensible. If you want to say that it's worth dealing with the flaws due to the ecosystem, fine, fair enough. But don't tell us that PHP is no worse than any other language. It's far worse.
Yes, the PHP ecosystem is friendly, easy, cheap, etc. etc.
But as a programming language per se... Come on, PHP.
It is wildly successful despite this and many other bugs.
I only wish that the people who spend as much time attacking PHP and it's developers endlessly would instead focus some of that energy into helping to improve PHP, but I guess some of us are just negatively charged.
Sad that we have yet another anti-PHP posting hitting the front of HN in as many days, let the hating re-commence (again)...
http://www.codinghorror.com/blog/2008/03/whats-wrong-with-tu...
Other languages like PHP (partially), BASIC or Pascal are case insensitive, so lookup has to be done case-insensitively which means that case has to be normalized, so transforming case of identifier becomes necessary. If it can't be done consistently, that's a problem.
The programmer can be sloppy/lazy and still have thing turn out largely as expected. If you're just learning how to program, this makes it a bit easier, since a whole class of possible problems goes away.
The only way to make it not work is to first change the case in one locale and then case-insensitive compare it in another locale. Why would this kind of operation ever happen? Any sane situation should "just work":
- in declaration convert to lower-case and save, in usage convert to lower-case and lookup -> has to work
- in declaration save original, in usage search all classes with case-insensitive compare -> has to work
How was that bug ever created in the first place? I get the fact that "I" doesn't match to lower-case "i" in tr_TR, but why does it matter when comparing strings which should be equal? Just be consistent in how both the declarations and usages are converted...
Granted given the usual pragmatism of PHP someone should have just hacked something in by now.
Just as an example, text-transform: uppercase has been broken in Turkish for all major browsers until I believe Firefox finally fixed it late last year, after having a bug open for nearly a decade.
Of course that might be bit late to do now, there is probably too much text encoded in the current format.
I blame Atatürk. If I had a time machine, I'd skip killing Hitler and travel back to the language reform time. "Do you know how much trouble this is going to cause us? Reuse the X, make one a dotted e. I don't care, this is going to fuck everything up!"
PHP is cool, it is useful, it is a magnet for bad developers. This way they don't pollute our ecosystems.
Not wanting to fix a bug because it's not worth the time or risks breaking backward compatibility is perfectly fine by me. But at least take a decision and say something.
If they don't plan on fixing it they should say something like "We believe this is a minor bug that only concerns a small number of users. In order to fix this we'd need to change X, Y and Z and make sure we don't introduce regressions. If you want to try and do it we'll be glad to review your patches. In the meantime you can use this workaround: [...]".
I hate it when I submit a bug report and it's being ignored. You also build a strawman argument with the "lot of open source software that you wanted to use for free". It's a bug and should be fixed (even if the fix is closing the ticket as "wontfix").
http://news.ycombinator.com/item?id=4188167
specifically the complaint that this problem manifests with lots of off-the-shelf software (although I suppose he didn't specify FOSS in his original comment).
However, I wasn't directly responding to that guy, I was more responding to what I feel has been aptly described as a "witch hunt" by others on this page.
It might not be an easy fix if you're not familiar with PHP's guts
10 years is a long time for someone to have the chance to get familiar with it.
Even if you assume that for 8 years, everyone was saying "oh, it will get fixed some time" even 2 years is a long time for anyone affected by this problem seriously enough to become familiar enough with PHP to fix the problem if that's the path that will produce the most value for them (ie. if there's enough value in some existing codebase or off the shelf software to warrant fixing this if there's truly no other workaround).
Still, I can see the sense in promoting major issues like this with PHP, but posting the bug report on the front page of HN is far less useful than, say, writing a blog post about it with some case studies of where the problem has been manifest, how people have dealt with it, the history of the bug, etc.
Actually that's a good blog post, might put it on my list ;)
We all know PHP has its shortcomings, but there appears to be a witch hunt going on here.
I think some of the witch hunt comes in attempt to steer people away from a language which is badly designed and has a million bugs which cannot be fixed without breaking most of the existing code written for the language.
Pestering a language like that is only fair.
While I'm sure it gets tiresome for those who for whatever reason have to work or prefer working in PHP, it is only a polite gesture to the software-developers who has yet to take that dark path.
If they can be dissuaded, they should.
It is important that people should be fully aware of the technical liability they are taking on when they adopt PHP for nontrivial projects.
It isn't reasonable to demand that other people fix the huge collection of weird bugs in your project. Particularly when they are not invested in PHP (any more). PHP's bug collection is a strong reason not to invest in PHP (any more). If it is important to you to encourage PHP adoption, then YOU fix the bugs.
I am not wasting my life working around this nonsense because there is no reason why I should have to. There are alternatives which already work correctly.
Don't trade off against the cost of rewriting.
Trade off against the cost of using any of the well-developed alternatives which do not have the same bugs, the same volume of bugs, or the same internal processes which generate and shelter bugs for years on end.
While I tend to agree that I would not use PHP for new projects, I would disagree that it's indefensible. All you need to defend it is, "it's easy." In the sense of, "it's nearby, it's within reach." If it happens to be the language installed on your system, its use is automatically defensible on those grounds alone.
It might not nurture you and love you and cherish you; hell, it may abuse you at times, as any language with idiosyncrasies does. It might even have more idiosyncrasies than other languages do. But those do not make a relationship indefensible -- merely difficult. And in some cases, the difficulty makes the love even more binding -- which is why we still have people who program in low-level languages, for example, even though those have all the more tendency to abuse you for the tiniest mistake you make.
It doesn't spontaneously fail. The languages functions are case-insensitive and they documented this. [1] [2] When you change the locale to Turkish the letters change. Thus, the class name changes and no longer works as expected.
So it is documented because it may not as expected, but it is not spontaneous.
I'd accept that you cannot reference class "info" using name "Info" in Turkish locale, but that's not the case here.
Case sensitivity changing depending on locale would be weird, but at least vaguely sensible. Identical strings no longer matching is just plain wrong.
Your suggestion that people improve PHP instead of attacking it is naive. PHP is, as you said, a big legacy open source project. As a result of that, it's basically impossible to make the extreme, breaking changes that many people (me included) think would be required to make it a reasonable competitor to the existing options. (And the PHP community is not especially inclined to change. It took years for short array syntax to get added to the language. If something as obviously beneficial as that is going to be hotly debated, making real, breaking changes is impossible.)
Faced with the alternatives of trying to radically change PHP (which is, as I said above, impossible) or to use and improve other languages and frameworks, I think the choice is obvious. It was one thing 5-10 years ago when there weren't necessarily good or mature alternatives, but we have many choices now. In my opinion, it makes very little sense to use something with as much extraordinarly painful legacy baggage as PHP unless you have an exceptionally good reason for doing so.
* Note that I am not including myself in this list. But any trivial search for "what's wrong with PHP", much less "PHP sucks" produces 5+ years of very bright, articulate, sometimes downright famous programmers making this same point about PHP. Most recently Jamie Zawinski at http://www.jwz.org/blog/2011/05/computational-feces/#comment...
And if you are going to design a new language (that's what "improved PHP" would be), you have very little to gain in basing your work on PHP. The ecosystem is in the current PHP, and it is as likely to transition to completely different language as it would be to transition to your "improved PHP".
As someone who would rather not ever work with PHP again, the best thing is to simply focus on other languages and environments, helping to bolster those ecosystems.
"...everybody kills Hitler on their first trip. I did. It always gets fixed within a few minutes, what’s the harm?"
For those that don't know Turkish, there is a faced of the language called vowel harmony. When suffixes are added to a word, which is common in Turkish for everything from pluralization, verb congugations to prepositions, the vowels in the suffix will be altered to match the last vowel. (Some Arab loanwords don't follow this, mind you, but it works 98% of the time.) So, the dotted and undotted vowels (except e for some reason) all follow this pattern.
(Incidentally, however, the problems could be solved by turning the single dotted i into a double dotted I, keeping the original symmetry. At that point, a lowercase dotted I would no longer break any system, since you could map them to be functionally equivalent for anything after the reform. While we're at it, I have a few ideas for English language reform...)
Right way should be involving in a process of developing standards, not changing some chars because some new tech come and has problems with the language ( going rampage as you mentioned earlier isn't also a valid solution ).
The Turkish I is one of the most interesting issues in internationalization.
Of course it will never happen, but I really think this would be a great idea for the next major version. Backwards compatibility is important but not at all costs. A language needs to remain agile enough to allow for the recognition of (and ultimately the fixing of) mistakes.
I'm currently having a go at Python + Flask in my spare time.
When you say you don't want to use PHP again and want to focus on other languages, you are saying you want PHP to die off.
Issuing holy decrees from their ivory towers more like. Meanwhile, lots of tremendously successful companies doing real work in PHP each and every day, at the coal face, where it matters. Does their hard work deserve this constant ridicule?
> The only way to improve PHP is to replace it, and we have a long way to go to get there.
Agreed. When something better comes along, I'll start using it (like how I switched from Perl to PHP a long time ago). The problem is, many "eloquent, smart programmers" are too busy "posting long, well researched screeds" to spend some time making PHP better (or making a better PHP).
Nobody seriously criticizing PHP is ridiculing people working with it. On the contrary, I personally applaud people having to, and succeeding at extracting diamonds with a broken pickaxe.
> The problem is, many "eloquent, smart programmers" are too busy "posting long, well researched screeds" to spend some time making PHP better (or making a better PHP).
A "better" PHP would be at its core so entirely different and incompatible with the current PHP that calling it "PHP" would be a complete misnomer. Since it would be such a different language/platform with only vague syntactic and semantic similarities, one might as well invest its time in the better designed, actively developed, battle-tested, currently available alternatives.
I rarely see this. I've found it hard to find a good criticism of PHP that doesn't find a way to insult it's user base.
Probably the best criticism of PHP has come from Jeff Atwood's recent post[1] (and even he couldn't go the post without slinging immature, and downright vulgar insults).
1. http://www.codinghorror.com/blog/2012/06/the-php-singularity...
If you could deploy (say) python-decorated web pages via apache (on el cheapo hosting services) versus write yor own server and figure out how to host it then the problem would be solved. We have the languages, just not the ecosystems.
Obviously I'm not the first to observe this. Mod_python exists, it's just not popular.
Some of these servers are so easy to install and use, so much EASIER than Apache, that it really gets ridiculous to complain about.
mod_python has been deprecated for years in favor of mod_wsgi, which uses an actual standard. That you don't know this shows that the problem is too much documentation guiding people to things which are no longer modern or standard. If you use Apache, use mod_wsgi, it is infinitely better.
webfaction costs $5.50/mo, lets you do proper Python deploys rather than endless hacks and has good support, if you need cheap Python hosting.
Also, PAAS offerings like Heroku and Engine Yard make deploying sophisticated rails environments far more convenient than their PHP equivalent.
> "sticking code snippets in web pages"
You can do exactly this in ruby with ERB, but many shy away from this approach due to a distaste for the bolognaise pattern.
You should try ruby/rails/sinatra on your next project, it will change your life.
This is a terrible, terrible idea. There are a few Python frameworks which have tried similar things, but Model-View-Controller was invented for a reason.
EDIT: “trivial to fix” as in, doesn’t cause regression, not necessarily that it’s a small change to the code base.
$classname = $row_I_got_from_mysql['classname'];
$object = new $classname;
http://blogs.msdn.com/b/michkap/archive/2004/12/02/273619.as...
The mapping between uppercase and lowercase can be completely arbitrary, and as long as it's used consistently you shouldn't get these kind of bugs.
http://en.wikipedia.org/wiki/Letter_case#Unicode_case_foldin...
It's not PHP's fault that accurately performing case transformations across locales is difficult; it's just actually very difficult. The solution isn't to "fix" the process of transforming letter case; the solution is to simply not transform the names of your identifiers. Unfortunately that is simple only in a very isolated setting; in the real world, doing such a thing is liable to break a lot of software.
This is a really good example of the problem at hand:
>The Greek letter Σ has two different lowercase forms: "ς" in word-final position and "σ" elsewhere.
The identifiers are lowercased multiple times; first at parse time, presumably using the locale of the OS, some setting in php.ini, or some fixed locale. (it doesn't, in practice, matter where this initial locale is set; it just matters that it's set at parse time.) It's then lowercased again at runtime; if the locale was changed at runtime, such that the casing rules in the two locales produce any differences, the identifier will not be found.
I'm not saying this to defend PHP; just to shed some light on the case-folding problem. Having case-insensitive identifiers is a design mistake.
> ...and has a million bugs...
> ...cannot be fixed...
> Pestering a language like that is only fair.
> ...who has yet to take that dark path
Wow that's a lot of emotive language. Like the man said, witch hunt.
The rest follows naturally. Anyway: Have an upvote for objectively dissecting my semi-objective analysis.
1. PHP contains a bug which makes class and function names containing certain letters, like I, fail when the code is run in certain locales.
2. This bug has been open for ten years and has not been fixed. It's not likely to ever be fixed.
3. Many similar bugs exist in the code base, due to the PHP team's approach to language design.
I'd argue that it solves the problems in the '00s that Visual Basic did in the 90's.
What I'd really like to see is a solution for '10s which fits that niche and is equally as productive, yet less horrible.
I am one of those who chose to work with PHP, and I'm getting more than tired about that witch hunt, to a point where I would actually punch someone.
I do realise PHP is not ideal, but as I always say, in the end it get shits done, and the vast majority of those problems or "design flaws" does not affect 99.9% of the community. Most of the people who bitch about it are not even users, in the heavy user circles we know of some of the issues, try to advocate for improvement, but seriously in almost a decade of using PHP, I could compile all those blog posts, and confidently say : I never had any issue whatsoever with any of the problems pointed.
And that's what most elitist around here forget, for 99.9% of its user base, PHP is not flawed, it works, easy to learn, easy to scale, easy to deploy, upgrade, easy to find developers...
While I get what you are trying to say, you are in no position to say so, and the community -the one that actually matters- already spoke, we have no major issue with PHP, so leave us the fuck alone please. If it bugs you that much, consult a therapist you have bigger issues than PHP...
If that describes you, I am sorry for you, and deeply encourage you to take on something new on the side, in a different language. Just for fun, learning and exploration. Just to let your mind get a feel for how the world can (and maybe should) be different.
I've done PHP. I've been there. So don't get me wrong. PHP has good sides. Yes yes, it does. But IMO (and I'm far from alone here) they are completely overshadowed by the bad sides.
Having dealt with every language under the sun over the last 20 years, PHP still has an as yet unbeatable sweet spot when it comes to getting stuff done.
BTW how do you think rails serves web pages?
i.e. this will print "bar":
<?php
echo foo();
function foo() { return "bar"; }Breaking changes in programming languages are not that uncommon, C# and Perl spring to mind from personal experience, but also to a lesser degree such things have happened with PHP itself (and it became better for it). In this case, it's actually a change that moves the runtime's behavior closer to what's expected. It's a change that improves internal consistency while also eliminating silly bugs like the one discussed here.
[1] actually, I don't care at all since I moved on to greener pastures.
Whereas I can have reasoned conversations with proponents of most modern languages, PHP is simply and unequivocally a complete and total failure of a language, and there is resultantly absolutely no room for concession when discussing the language.
PHP is broken and should never be used, and if there are use cases that the alternatives don't address, we should work to address them.
What alternatives meet your standards of not sharing qualities of PHP while matching the quality of simplicity in deployment (of which Python and Ruby instantly fail)?
But that is fine. Not all languages can or should be mind bending or define its own paradigm. So yeah, if all its problems was somehow in all unlikelyness fixed, it would be fine. It would be fine, but it would in no way "rock".
In a corporate technology organization there is no justification.