Slashdot Mirror

You forgot to link to the Fractal of Bad Design diatribe.

The core is broken. While you have namespaces and patterns to apply inr your code, PHP core functions still don't have namespaces, class, don't even have a pattern in their names/parameters (to not blame the real lack of classes for strings, by example). This only to start. If you want to get deeper: http://me.veekun.com/blog/2012...

This list should be updated. With a bit of luck it won't be a fractal too.

So of all the languages they could have forked, they decided to fork PHP? Okey-dokey.

There are plenty of languages that are equally expressive while still being far faster and more efficient.

And available on entry-level web hosting? The only language I know of that's more widely supported on shared hosting is one that's been called a fractal of bad design.

This article explains why: http://me.veekun.com/blog/2012... I've since moved onto Python for all new webdev projects.

Let me know when they fix at least half of the issues listed in this article .

Not that. PHP's only real problems are inconsistent naming and parameter order. (Interestingly enough, a problem partially shared by python in spite of PEP 8) Unlike Python, it doesn't suffer from any serious design flaws.

Is this some kind of joke? Python's use of syntactically-significant whitespace is not in the same league as all the issues PHP has.

Perl5 CGI::. text/html and response code of 200 is the default returned by header().

There are also tricks to get PHPish code-embedded-in-static-content look and feel from Perl, but mostly people don't use that due to a general recognition that only those crazy PHP coders want to deal with that level of clutter and it's better to keep the markup inside your quoting constructs.

Anyway, futher lambasting PHP would be BTDT at this point.

Yes, you can enable SSH on ESXi. There are also varying levels of support from third parties, most of which are easier to deal with than Microsoft.

Perhaps I should clarify what I mean when I say I'm a "Windows sysadmin"... For the past two years, I've been doing systems work with Windows. For the first year, it was mostly in a bog-standard admin capacity, but for the past year I've been working exclusively on a project in Windows Server 2012, using PowerShell heavily. I'm now in charge of maintaining and improving about 10k lines of PowerShell scripts.

Powershell is the second-worst language I've encountered in almost two decades of programming. Here's a few reasons why:

• It's supposedly all based around objects, but you can't natively define your own classes. You have to embed C# for that.
• The "pipeline" passes objects from one command to the next, but there is no standard for what semantics a passed object must support.
• Opaque objects can't easily be manipulated or constructed for debugging.
• Commands are loaded modularly, but there are no namespaces. Collisions are inevitable.
• No include-like functionality for scripts. You can import (with .) a modular script multiple times, but it'll run multiple times.
• Multiple overlapping APIs. In addition to the PowerShell native commands, there are interfaces to .NET, WMI, COM, and command-line executables, any one of which may be the expected (or only) way to accomplish a given task, and of course the available features change with every revision of Windows.
• Context-sensitive errors. Assign several kinds of Get-* results to variables, and you can check that variable safely in an IF condition. Checking the Get-* directly in the condition will throw an error if the Get-* operation returns an empty set.
• Moving to an inner scope is copy-on-write.
• Far too much boilerplate to declare constants (38 characters) or globals (27 characters).
• Symbol aliases like "%" and "?" are not obvious when reading old code, and text aliases are also rarely intuitive unless you use them frequently.
• No cross-platform support whatsoever.
• Incomplete support in older OS versions, and no upgrades.
• No unified documentation (due mainly to aforementioned modularity hell and split APIs)
• Whitespace sensitive.
• No native support for test-driven development.
• No support for multiple entry points.
• Worse multithreading support than Perl.
• Little control over command output. Either you nitpick each command to accommodate its error, warning, and output streams, or you change the global error-handling variables
• As with all Microsoft products, absolutely no guarantee of support beyond the current version. As soon as Microsoft decides that SuperShell is the next big thing, PowerShell will go join other abandoned systems like COM, WSH, and VBScript.

My theory is that PowerShell started as a way to tack .NET support onto batch files, but then some brain-dead executive thought it'd be a suitable competitor to Bash, so they had to add pipes, but it's just gotta use objects, because Windows is all about the objects! Then somebody actually tried to use it for something productive, and realized it was still limited, so they added half-assed module support so it could be more useful later. Executives saw the progress, and declared that it had to be integrated into all the new 2012 stuff, so that meant that each team had to figure out their own way to make PowerShell make sense. Of course, in typical Microsoft fashion, nobody thought to look over a

This is the next step. You start using a mature framework, preferably in a language with far better design than PHP like Python or Ruby.

Here's what I think: If you know what you're doing, doing things the right way takes no longer than doing things the wrong way when you start.
Example

So the end result is that it's a lot cheaper to do things the right way, because you start off almost as fast, and end up not having to slow down to deal with the headaches that exist as the thing gets larger.

And if you're one of those types that likes a CMS, try Mezzanine and tell me if it's still hard to get something other than PHP up and running.

This link cannot be shared enough:
http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

yeah, but this is PHP - a fractal of bad design.

PHP: a fractal of bad design

There's even a website dedicated to PHP WTFs

Consider that a language (rather than a programmer) causes a WTF moment when it behaves other than would intuitively be expected according to its own rules of grammar. On that basis alone, PHP wins hands down.

Not the best PHP WTF site. Try PHP Sadness or A Fractal of Bad Design or even CodingHorror. In the interests of balance: A Fractal of Bad Design: A Rebuttal

And here's an even better article about specifically what makes PHP so awful: http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

It's also skewed to "languages used in Github projects". More importantly, would the people programming in a real WTF language not even know that it was such a WTF?

How did MySQL get such critical mass?

Probably the main reason is that it has a "design philosophy" of "if you can't do what the user wants, better to do something and say it's all OK than to give an error", which some people mistake for ease of use.

Coincidentally, the same philosophy of PHP.

My oppinion is that Javascript is not bad as a scripting language, but we are abusing it and twisting it beyond its original purpose.

I disagree with that sentiment. Like PHP it gets used a lot and for that reason plenty people think it must be good for something, right?

Well, uhm, no. Wide availability and popularity do not a good language make. You have a point about the stretching but I disagree that it was any good to start with. Merely really, really widely available. And apparently well-suited for the kind of non-thinking that abounds in its niche. Which makes it enterprise-y, in a sense.

And don't forget his follow-up: http://me.veekun.com/blog/2012/07/28/quick-doesnt-mean-dirty/

Then perhaps you should be using the companion function is_numeric() on the variable before attempting to convert it and then you wouldn't have this problem of vague return values!

Sure, there are always ways to get stuff to work despite the language and API's bad design, I myself get stuff done in PHP when I have to and hey, it beats writing machine code by punching holes in punch cards, but that does not mean the design is not bad and harmful to productive development... Unless you can find a rational reason why intval on an object should return 1, while intval on an array returns 0, and for so many other equally absurd decisions in the language, runtime and API. Try giving this a read:

http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

Here's a much more useful and accurate review of PHP.

Someone did go on, and on, and on, on this topic. Interesting read that makes never want to go near PHP again:

http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

"The language is as good as the developer using it" is a faulty argument. Read PHP: A Fractal of Bad Design for a painful, pedantic and tedious rebuttal.

TFTFY

"The language is as good as the developer using it" is a faulty argument. Read PHP: A Fractal of Bad Design for a good rebuttal.

I like your link to a page containig a picture of a hammer with a claw on both ends.

I raise you a link to a page describing a pentagonal room. PHP: a fractal of bad design.
http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

I cant believe nobody has linked to that blog posting yet. It's a classic.

I can’t even say what’s wrong with PHP, because— okay. Imagine you have uh, a toolbox. A set of tools. Looks okay, standard stuff in there. You pull out a screwdriver, and you see it’s one of those weird tri-headed things. Okay, well, that’s not very useful to you, but you guess it comes in handy sometimes. You pull out the hammer, but to your dismay, it has the claw part on both sides. Still serviceable though, I mean, you can hit nails with the middle of the head holding it sideways.

Elite computer scientists look down upon both because they are perceived as quick and dirty hacks. But that doesn't matter; for many applications, a quick and dirty hack is good enough.

If anyone wants to know why this is now a crock of shit, look no further than this post: http://me.veekun.com/blog/2012/07/28/quick-doesnt-mean-dirty/ It goes through the development of a simple web-app using proper technologies as the author discovers and uses them for the first time, and serves as a good introduction to Flask, SQLAlchemy, and Postgres.

Quote:

This is a recurring sentiment: developers telling me, well, yeah, Python may be all cool in your ivory tower, man, but like, I just want to write some programs.

To which I say: what the fuck are you people smoking? Whence comes this belief that anything claimed to be a better tool must be some hellacious academic-only monstrosity which actively resists real-world use?

...and so the contest to find the worst combination of server software technologies begins. I'm stuck somewhere between unmaintained metamorphic perl and a ghetto re-implementation of Excel Services.

PHP and ... anything? PHP is a fractal mess. Few other tools can make that claim.

http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/ http://tnx.nl/php.jpg http://www.quora.com/PHP/Why-is-PHP-hated-by-so-many-developers It's a bad horrible language, and why should I or anyone else be forced to use it.

Sure, PHP has its fair share of design flaws,

I think you seriously understate what's wrong with PHP. Beside all the things that is mentioned in that article, I love how you suggest several php frameworks that attempt to be like Rails but all built on such a flawed language.

And Rails is not hard to deploy any more... that argument is several years out of date.

Rails is great, providing you are willing to do everything exactly the way you are supposed to according to best practice. The problem is that some times in the real work you have to do things wrong (either to meet a deadline or just because you are stuck interfacing with a shit legacy system that nobody will pay to rewrite) and then Rails just refuses to play ball.

Short cuts are a part of commercial development unfortunately, that is why so much commercial stuff is written in PHP.

I always compare Rails to Pascal: A great language for learning best practice but lack the flexibilty that comes with languages like PHP or C in comparison to Pascal.

Sure, PHP has its fair share of design flaws,

I think you seriously understate what's wrong with PHP. Beside all the things that is mentioned in that article, I love how you suggest several php frameworks that attempt to be like Rails but all built on such a flawed language.

And Rails is not hard to deploy any more... that argument is several years out of date.

I've worked with Drupal for cms websites and seen it used on other customer sites. You should never use it, seriously. It's remarkably similar to early php in being a fractal of bad design. They are slowly trying to improve it, but their attempts at improvements are woeful. Some problems (which they've attempted to address, but many of which still plague users):

Hundreds of tables with the most Byzantine schema you can imagine, even for incredibly simple needs
Attempts to allow customers to define the db schema by adding fields etc
Code in the db - that anyone ever thought this is a good idea is a huge red flag
Upgrades are often incompatible
A horribly broken plugin system and ecosystem, resulting in sites which load hundreds of plugins to support simple tasks, and therefore have a huge attack surface and a huge amount of unmaintained, scarily bad code. I've seen sites with hundreds of these modules loaded.the learning curve is huge and the code extremely fragile due to the above decisions
Content is all stored in 'nodes' which are infinitely flexible, and therefore infinitely opaque and difficult to work with
There are no pros or professionals working with Drupal - anyone who was a pro would have run a mile a long time ago, so don't listen when someone says 'oh well you just don't know drupal well enough'

I dread to think what would happen if security professionals looked carefully at many drupal sites due to the above, particularly the modules situation. The closer you look at the code, the worse it gets

If you're thinking of using it for a php cms, think again, look at Wordpress for example - the code is relatively clean (though it is still php of course), the plugins are better maintained and fewer are required, upgrades for security are no hassle, and they didn't come up with crazy ideas like code in the db in the first place. I'd personally choose other options/platforms, but at least with Wordpress the environment is pretty sane for a small time cms, easy to adapt and friendly for an end user.

I code in Ruby for a living (Rails), and I think it's a really fun language. Which is something a fair number of rubyists say, and which is something you don't hear a lot of other folks say about their language of choice. For what that's worth...

This. So much this.

Over the years I've used various languages to some degree... C, C++,Java, PHP, Perl.... and Ruby is simply the most fun and most expressive. I'll allow that all these languages have their strengths. (ok, not PHP). Python, too has many valid proponents and use cases, but I just can't have fun in a whitespace sensitive language. Java - I think is nice for people that like to type a lot. The modern day COBOL. But if IIRC, the fastest ruby interpreter is currently JRuby, so I can't entirely fault Java. C and C++ is obviously best for kernels and libraries where speed matters a lot, but obviously horrible for web application development.

For my own interests in web application development, Ruby on Rails is a sweet spot... I can make a lot of money doing something really fun. What's not to like about that?

The fact that the language is predictable and not error-prone out the ass, for one.
PHP is exceptions wrapped in a language.

I moved away from that crap the instant I found out how buggy that crapware is.
A language developed by people who didn't even understand the difference between == and === has lost all hope of being taken seriously.
And the fact that they even ARGUED against it is even more annoying.

I know it gets linked ALL THE TIME in anything relating to languages, but it really needs to be read by every single person ever.
PHP seriously needs to die already. It CANNOT be fixed.
To use the tools in a box example, PHP is like hammering a nail with a sandwich. It is literally pointless and fruitless to even bother, because all you will end up with is pain, anger and annoyance in the end, and maybe literal bleeding hands after you smash either your keyboard, wall or monitor in frustration at how a language can somehow be worse than Visual Basic.
PHP - a fractal of bad design

What's more elegant and nicer in Python than PHP?

Python isn't a fractal of bad design.

Here are some good reasons to avoid PHP: http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

Yes, I recognize the language's many obvious (and many not-so-obvious) failings...

You're underselling the problems with PHP. Seriously. PHP is a hideous, three-headed stepchild of a programming language and I know nothing about it that's fun, functional, or useful. Its not Fun, or Funny. http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/.

I wouldn't dream of using PHP because besides being one of the few languages where every feature is broken in some way, I needed TDD and MVC baked in as well as threading support.

Don't get me wrong, PHP has many faults, but TDD is a development methodology, and not a language feature. You can do TDD perfectly fine with PHP, using PHPUnit or other test suites. MVC? Also not a language feature, but a design pattern. There are plenty of simple ways to implement it, and many PHP frameworks that utilize MVC by default.

If you want to bitch about PHP, at least stick to the 1000s of points that are actually PHP's shortcomings.

The speed issues were definitely a huge problem. Every Ruby on Rails project I've ever run on my test server, including the super-simple to-do list given in the tutorials, have ground the execution of said project to a halt; something that would take PHP milliseconds to do would take 30 seconds minimum while Ruby fired itself up.

Personal Anecdote FTW!

Unlike you, I wrote, deployed and maintained a RoR app in a professional environment that got a minimum of 40,000 hits per day, every day. It worked like a champ with no speed issues, because a) I worked with the server guys to ensure the web, application and database servers were tuned, and b) I know how to use a profiler.

I wouldn't dream of using PHP because besides being one of the few languages where every feature is broken in some way, I needed TDD and MVC baked in as well as threading support.

I would've used Java, but (as usual) the artificial deadlines required rapid deployment, and the minimum viable product would've taken too long to code in Java. I could've just as easily gone with Perl, but using some gems that allowed me to basically drop them in and go saved lots of time I would've wasted coding the same things in Perl (even though CPAN rocks).

Virtually every feature in PHP is broken somehow. The language, the framework, the ecosystem, are all just bad. And I can’t even point out any single damning thing, because the damage is so systemic.

fun read

PHP has some warts, sure, but the most common criticism has been just inconsistent naming. There used to be some moaning that it was "object oriented", which I and many others considered a plus, but that's hardly "fundamentally wrong". I guess I'm missing something here?

This critique was going around recently detailing the problems with PHP. I'm not partisan, but it's clearly more than just a case of messy evolution:

http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

You can't just fix PHP. There's no one place to fix it, it's built out of design errors on top of poorly thought out implementations and emulation of previous mistakes. We're talking about a language created by a man that argued against type-observing equality operators. PHP is just bad and brain damaged - it probably would have died out by now were it not for those cocksuckers at Zend that went out and created a rock-solid, easy to deploy, fast implementation of this steaming shitpile of a language.

PHP is a language for getting thing done. Just like any toolbox, you can build great or terrible things with it. It's like perl in that way (and I've done plenty of both). If you code well, there's very little to complain about with PHP.

I might be misinterpreting you here, but this sounds like a point responsed to in PHP: A Fractal of Bad Design:-

Do not tell me that "good developers can write good code in any language", or bad developers blah blah. That doesn't mean anything. A good carpenter can drive in a nail with either a rock or a hammer, but how many carpenters do you see bashing stuff with rocks? Part of what makes a good developer is the ability to choose the tools that work best.

You also said:-

And personally, I wouldn't want it any other way. I don't want language designers deciding they know what I want to do better than me.

I also think the problem a lot of people have with PHP is its inconsistent and illogical bad design, which isn't the same thing as flexibility. I don't think having a logically designed language necessarily means one that forces its philosophy on you. I'll note that the fractal post referenced above also states that:-

I assert that the following qualities are important for making a language productive and useful, and PHP violates them with wild abandon. If you canâ(TM)t agree that these are crucial, well, I canâ(TM)t imagine how weâ(TM)ll ever agree on much.

* A language must be predictable. Itâ(TM)s a medium for expressing human ideas and having a computer execute them, so itâ(TM)s critical that a humanâ(TM)s understanding of a program actually be correct.

* A language must be consistent. Similar things should look similar, different things different. Knowing part of the language should aid in learning and understanding the rest.

* A language must be concise. New languages exist to reduce the boilerplate inherent in old languages. (We could all write machine code.) A language must thus strive to avoid introducing new boilerplate of its own.

* A language must be reliable. Languages are tools for solving problems; they should minimize any new problems they introduce. Any âoegotchasâ are massive distractions.

* A language must be debuggable. When something goes wrong, the programmer has to fix it, and we need all the help we can get.
 

(Apologies for the cut-and-paste splotches, but I don't have time to fix them right now)

I can't even say what's wrong with PHP, because -- okay. Imagine you have uh, a toolbox. A set of tools. Looks okay, standard stuff in there.

You pull out a screwdriver, and you see it's one of those weird tri-headed things. Okay, well, that's not very useful to you, but you guess it comes in handy sometimes.

You pull out the hammer, but to your dismay, it has the claw part on both sides. Still serviceable though, I mean, you can hit nails with the middle of the head holding it sideways.

You pull out the pliers, but they don't have those serrated surfaces; it's flat and smooth. That's less useful, but it still turns bolts well enough, so whatever.

And on you go. Everything in the box is kind of weird and quirky, but maybe not enough to make it completely worthless. And there's no clear problem with the set as a whole; it still has all the tools.

Now imagine you meet millions of carpenters using this toolbox who tell you "well hey what's the problem with these tools? They're all I've ever used and they work fine!" And the carpenters show you the houses they've built, where every room is a pentagon and the roof is upside-down. And you knock on the front door and it just collapses inwards and they all yell at you for breaking their door.

That's what's wrong with PHP.

"But come on: if you have never programmed, *any* language will teach you the same thing?"

Not with the same degree of ease or utility.

PHP has virtually no internal consistency. It is a hodgepodge of utility functions, many of which do almost the same things, but take different parameters, in different order even. It was (is) a project in which contributions were just taken willy-nilly, and incorporated into the product, seemingly without regard to any sort of organization.

And object-orientation? A weird kind of object-orientation was sort of tacked on, in... what was it... version 5? While other languages have had that as a fundamental infrastructure from the beginning. Ruby, for example (I'm not certain about Python) is object-oriented from the ground up. The language is mostly written in itself. (The standard library does contain some C for performance.)

While many languages are "Turing complete" -- that is to say, given enough diligence they can theoretically accomplish anything that any other language can -- that does not mean that they are "equal" when it comes to everyday power or ease of use. Some are vastly more consistent and intuitive.

Here is an excellent example of what many programmers think of PHP. I did not make this stuff up.

No, for educational purposes, PHP is about the worst thing I could think of. I would advise someone to start out on C itself -- horrors! You can see how much I feel this -- before I would suggest PHP.

"PHP is used for one thing and one thing only - to generate CGI-like applications that shit webpages. If you are using it for anything else, you are using it wrong. If you have strange/complex requirements, or need to scale horizontally, you are using it wrong. If you need a stateful environment (where threads usually make sense for some tasks), you are using it wrong. If you need a GUI, you are using it wrong. Etc etc."

I don't disagree, but the point is other technologies do all that and do it better, so again, why bother PHP?

"but bad PHP code is usually easy to spot"

If you believe this, I suspect you're one of those people who doesn't actually understand why PHP is bad. One of the biggest problems with PHP is that it has literally hundreds of extremely subtle issues that can cause real bugs (e.g. reversed ternary operator chaining). These issues aren't simple to spot, no matter how good you think you are, and this is really the fundamental problem.

"Can't say the same for Python or Java. And the quirks."

Absolutely you can, because they don't have these hundreds of quirks that PHP has, not to mention that Java wont even compile some of the things that PHP will silenty fail on.

"Because the application is basicly re-initialized from scratch each time it is run, you want it to exit as soon as possible"

Er, that's the whole point of threading - if you want something to happen in the background, you can throw it off in a thread, and respond to the client without having to wait for that processing to finish. This ironically means you can't exit as soon as possible and respond to the client in some cases, you have to wait for processing to end, even if that processing isn't necessary for the client to receive their response.

"There were some projects in the past that tried to implement thread support and failed - mostly, due to the fact that most libraries that PHP uses weren't threaded, and general lack of interest. "

Lack of interest being because anyone needing it just ended up using a proper language, like Java, instead, not because it's unnecessary.

"I personally hate Python. I cannot use a language that treats me like a child. But yes, Python can be used in a plethora of cases where PHP is a bad idea - but, if I'm using Python, why not use anything else?"

I agree, I don't like Python either, but the point is that if you have Python as an option, then PHP is always a bad idea, because even for the small niche areas where you can just about get away with PHP, Python does it better, as does for example, RoR.

"The same argument can be applied to any language. PHP (with a decent framework) is quite usable, easy to learn/troubleshoot (despite of the quirks), and delivers."

Again, if you believe this, then I'm not convinced you're aware of PHP's many subtle issues. They are well documented, most recently, and probably most extensively here:

http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

"Web-based applications tipically have a (much) shorter lifespan than desktop applications, so even the long-run cost of "maintenance" isn't a real problem."

Do you have any evidence to back this up? The only reason I can see it being true is that the web hasn't been around as long as the desktop, there's no evidence that I'm aware of that web applications get taken down and replaced quicker than desktop applications.

The problem is that your argument seems to be weighted entirely on the rather weak get out clause that if PHP has failed then someone is doing it wrong. Therein lies the fundamental problem, it means anyone using PHP is always doing it wrong, because relative to use other options, PHP is always a failure - it's always inherently more buggy, slower to develop with, poorer performing, harder to maintain or a mix of those issues than just using an alternative technology would be, so again, what redeeming features does PHP have that make it better than any of the alternatives like Python or RoR, or even something JIT'd like C# or Java?

PHP is garbage. Bad design all over the place. And I'm talking both about the language as well as the standard mess it calls a "library". It is the new BASIC.. stay away it'll damage your brain. For details see:

http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/

There are better alternatives if you want to go the dynamic route: Ruby on Rails and I hear Python / Django is great too.

There's nothing wrong with Java as long as you know how to use it. But its always good to learn a new language. ASP.Net is also nice if you don't want to go dynamic.

The hardest part about moving away from Java is losing all the cool static analysis tools that are incorporated in Eclipse as well as tools such as FindBugs. But our experience with RoR (in spite of it missing some needed feature many Java frameworks have).

In summary: learn anything but PHP.. it truly is garbage that must die.

There are such things as bad tools.

The tool is bad if the defining characteristics of the tool are its misfeatures. Take out the crap bits from PHP and it starts to not be like PHP.

They've been deprecating the crap bits (stuff like magic quotes, register globals, addslashes) but there's pretty much lots of crap left and they even added some more.

http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/