Slashdot Mirror

PHP is a horrific language. Most people that use it

...haven't read JavaScript: The Good Parts. PHP and JavaScript have a surprising number of pitfalls in common, such as difficult-to-memorize rules for == comparison. True, there are problems with PHP that are very annoying to work around, as Eevee pointed out in her famous essay. But as with JavaScript, there are also a few common-sense coding standards that make the worst problems less likely.

Nobody should use it. No, not even current versions. It's still broken.

Do you block Wikimedia sites and other sites using MediaWiki software?

Because PHP is still a fractal of bad design.

Thanks for taking the time to reply.

Ad hominem fallacies aside (*) that doesn't change the fact that some programming languages are total shit.

What is THE purpose of a programming language? To communicate with a machine. You can communicate in an obtuse way, verbose way, in a precise way, in an ambiguous way, etc. There is a range of QUALITY. There is poor communication and there is good communication.

The reality is that ALL programming languages suck -- some just more then others. One of the properties of a good programming language is that it is consistent. i.e. See PHP is a fractal of bad design

> Sometimes I think you just hate any language that's actually useful ...

IF I was idealist I wouldn't use any programming language -- but that is not realistic. I'm a pragmatist -- things need to get implemented in the Real World TM. However, that doesn't mean I'm going to just blindly accept and ignore the problems of a language.

> ... extremely useful JavaScript ..

Let's talk about Javaschit.

Is it useful? Yes! It has become the new BASIC of the millennium. It is ubiquitous.

I'm NOT against useful languages -- I'm against the BAD DESIGN and IMPLEMENTATION of them.

Do you know how many man years are wasted tracking down bugs simply due to misspelling??? All because the language designer was too fucking lazy to make the KLUDGE "use strict"; the DEFAULT. It's as if NOTHING was learnt from the experience of BASIC. Gee, if only the computer could tell us about misspelled variable names, oh wait, they can! Good engineering is about FAIL EARLY. Javascript was never designed with that mindset -- it was literally hacked together in 10 days. And 20+ years later we are STILL paying the price.

On the other end of the spectrum we have over-engineered shit like Boost where a simple to Read and Write ~25 lines implementation of CRC32 turns into 1,100+ lines of Crap++. WHEN was the last time you _actually_ needed to modify a CRC implementation??? If you need a stronger hash than CRC32 then, chances are, you are probably using a DIFFERENT hash such as FNV, SHA1, etc. due to a) performance, or b) more cryptographically secure (i.e. less collisions.) reasons. The Boost guys have become so obsessed over one little tree that they COMPLETELY missed the entire fucking forest.

Let's talk about C. It was a stupid decision to default every function as returning int. Why wasn't the return type mandatory? Having to run a "lint" program is a SYMPTOM. So why wasn't the CAUSES addressed?

Let's talk about C++. We are STILL waiting for modules -- something that has been standard in Pascal for 35+ years! Why aren't error messages _standardized_ ?? One of the few things MS Visual C++ does right -- is to provide an unique error code. This makes it easier to search for solutions. Go figure!

I am extremely vocal about shitty engineering practices because I'm tired of having to deal with other people's retarded designs and waste MY timing tracking down WTF is wrong with their broken, inconsistent, implementations.

If nothing is ever said about WHY said designs are crap then nothing will ever change.

I am only one voice out of many saying WHY PHP sucks (When even diehard PHP users say PHP needs to die you know there is a problem.)

People who use PHP are either ignorant, stupid, lazy or some combination of them. But that should come as no surprise -- it was designed for non-programmers. Gee and is there ANY wonder it has problems when any decent prog

https://eev.ee/blog/2012/04/09...

Enjoy Fractal, Hardly, and a synthesis of the two by analogy to Douglas Crockford's JavaScript: The Good Parts

Python is the classic example of implementation-defined semantics. The semantics of Python are whatever the reference implementation does. This is always a bad sign, but let me give you an example.

Most Python programmers don't know exactly what the rules are to decide when a new variable is created. People used to Algol-like languages (e.g. C) might naively think that a variable is scoped to a block, since Python seems block-structured. They would be wrong. Python variables are scoped to functions and classes. Oh, and comprehensions. And generator expressions. And probably a few other things that I don't know about.

Here are a few examples, but the best way to get a crash course in how broken the variable semantics are is to try (and fail) to write a compiler or interpreter for Python.

The brokenness of the object model is uncontroversial. Every object model based on that of Simula is broken. Just ask your favourite search engine why "OOP is broken" and you'll get it all. (See Smalltalk for an example of a less-broken object system and Haskell for an example of a principled class system.)

And of course "everything is an object" is flatly untrue; unless you are specifically doing simulation, most interesting things in the world are not objects.

If you’d like to specify the language which you think is more suitable than PHP for projects where PHP is often a sensible choice, I’ll be more than happy to come back and offer some specific examples of its failings

I get the impression from eevee's notorious "fractal of bad design" rant that she'd prefer Python. I've been trying to keep my own page about the issue more nuanced, distilling the problems that "fractal" mentions into a set of coding standards, inspired by the work of Douglas Crockford, and another set of failures that coding standards alone cannot prevent.

So where does, say, Python fail in comparison to PHP? (Other than ability to collaborate over channels that are broken in that they mangle leading whitespace.)

Doesn't matter what language you use, bad developers are universal.

It's a lot harder to find truly bad developers among, say, the lisp crowd, than it is to find truly good programmers among the PHP crowd. I'm saying what you're saying is idiot bullshit rationalisation for idiot PHP programmers, but I repeat myself.

Which stands to reason, as PHP-as-a-toolset is, er, not very good. Spectacularly so. Better programmers know they need better tools and will move where they can get them. (Compare and contrast the desperation evident in the endless stream of ``transpile-to-javascript'' contraptions.)

The thing is PHP 7.2 is actually pretty good, and 7.3 is looming.

``Pretty good for a pile of poo'' is faint praise, and your ``oh yeah it'll only get better''... syeah whatever.

But let's be honest. Most of the pro-grammers are in fact not very good, but by the same token, much of the code people want written those people apparently don't want to be very good, they just want it to be done however much gruntwork it takes. That neatly explains the popularity of PHP, java, and a couple others: They take a lot of gruntwork to get moving.

Especially PHP espouses this attitude of chasing ``the semblance of programming'':

PHP is built to keep chugging along at all costs. When faced with either doing something nonsensical or aborting with an error, it will do something nonsensical. Anything is better than nothing. -- PHP: a fractal of bad design

``Lookit, it does something. I must be doing something right, right boss?''

I've been doing 'C' for a _long_ time (and I remember and used the =+ and =- operators).
I haven't run into these over-complicated details of 'C'; maybe I've missed them. Elegant,
yes, but over-complicated - no!

You don't see it. Perhaps you're simply too familiar with the thing to see what's right under your nose. The kid does see it. Or maybe he's being a special snowflake. Who knows?

Personally I think C is by no means perfect, there's UB in every nook and cranny, but on balance it's a useful tool for the knowledgeable. If you want overcomplicated, look at PHP. It doesn't have the trickiness that comes with the industrial power simple tools like C sport (and Unix famously has), but it does borrow drawbacks from every idea it incorporates, mainly by failing to understand wtf they're trying to do at every opportunity. And yet the thing is massively popular with a certain class of users. None of whom are very bright when it comes to writing programs, because if they were they'd've ran away screaming long ago. As have the good language developers, and yes, to those in the know, it shows.

Anyway, the "overcomplicated" argument is bunk and obviously reaching. It makes no sense to rewrite in another language the entire code base of a high quality project just because it makes one special snowflake feel safer. Especially not when said snowflake is probably only marginally trustable writing the thing, leaving contributing code so far in the mist it is funny in and of itself already. So the real reason is likely something different. Which it is, in this case. The question is a slur and a political one at that. Notice that rust has become a rallying point for a certain crowd with certain political views and outlooks. So the quoted question was really about politics, and it's fairly safe to say that anyone embracing rust is thereby making a political statement. Just like embracing poetteringware is a political statement, even if many in the scene are incapable of discerning that they are making a political statement by embracing poetteringware, since they got into computing exactly because they wanted nice and predictable things to play with, not those pesky humans and their politicking. The politicking came calling anyway; you can see it because of the fantasticallly poor quality of the code and the design and its mysterious success at adoption in the face of better quality alternatives being readily available. All those technical merit discussions weren't about technical merits. The opposition had lost before they started because their technical arguments weren't about what was really being discussed. And so we're stuck with fantastically bad code doing far too much for comfort and making itself artificially indispensible at a sensitive spot, where it really has no legitimate business being in the first place.

Likewise, the one bid to rust fame so far is in things done by mozilla. The torbrowser project is not mozilla, but heavily dependent on mozilla, so they more or less have little choice to acquiesce. The big thing is that they're not just standing by and have it happen, no, they're going big on embracing rust. So they're convenient poster children that aren't mozilla, making them good propaganda material. They also happen to have quite a strong strand of SJW going on, see the ongoing Appelbaum spat. Politics and code, what could possibly go wrong?

What is taught is being lazy - let the language do all of your thinking

"Well, what else is a computer for?"

This is a common theme in computing. Pervasive, even. Not limited to programming either. The whole "app" fad has shades of this, and so do political attempts at "progress" through "digital transformation", or whatnot. That scourge from that racketeering marketeering company, "windows", is a fine example. "N

Read this, don't feel bad: https://eev.ee/blog/2012/04/09...

I'm a mere 20-year Obj-C developer, and I'm frustrated by some Swift design decisions, but I'm more perplexed by your questions.

- Swift has "var" and "let" because they're completely different. It's for the human's benefit, more than the computer's. And no, it's not determinable by the compiler. (You could have a field in a class which doesn't happen to be modified, but then somebody imports your code as a library and uses it in a way that modifies this field -- boom, suddenly "let" has to be "var", and all bets are off, in your library.) You might well ask for file permissions to be automatically set: if user X tries to write to file Y.txt, then apparently they need write-access to it, so the system should just grant it, right?

- Data is mutable or immutable depending on whether you use "var" or "let" (see above). I'm not sure what the complaint is here. Compared to Obj-C, it's more concise, more consistent, safer, just as performant, and extends easily to all value types. There are ways Obj-C is better, but this isn't one of them.

- It's fully compatible with C, so if you need "volatile", just write those 5 lines of your program in C. Everybody has their own definition of "systems programming language", so no language could possibly make everyone happy. (My dad is sad that there's no "register" keyword.) Your kernel has some parts written in assembly language, because even C isn't enough. There's no dishonor in using a different language for part of your program when it's needed.

- "...what's up with that?" I have no idea. If you want to provide details and sample code, there are plenty of Swift forums on the internet that can help you. An interview with Lattner is really not a good place to get technical help with vague problems.

- Finally, a decent question! It's true that Swift isn't as dynamic as Obj-C. I wonder if there's any plans to improve this situation. The infrastructure is certainly there.

- Why put the type name last? That's what most modern languages do, when they're not trying to look exactly like K&R C: Python, Go, F#, Typescript. It's easier to write, easier to read, faster and easier to parse, and overall more consistent. Unless you need 99% syntactic compatibility for old C programmers (like Java and C# did), there's really no reason to put the type first.

I've only done a very little PHP work so I don't know it well...but, this might be one language to not give the benefit of the doubt:

PHP: a fractal of bad design

I'll use whatever I feel like, or think best fits the program, whatever is available, or whatever the job requires. Asking how often I "switch" is asking how often a tinkerer "switches" toolsets between woodworking, metalworking, electronics, house painting, house cleaning, cooking, you name it.

The analogy of a nearly but not quite entirely unusable toolset is an apt one, and in that light it's quite amazing people try so hard to make it work against the odds. Me, I'm not about hammering the problem into my preferred solution providing tool by any brute force necessary. I'm about finagling a solution from the grasping hands of the problem without it realising it's been robbed. That's an entirely different mindset, and one in which the posed question has no meaningful answer. So, if this is the question you feel the need to ask, now you know what your answer ought to be. Curiously, there are a few other languages with "fits all problems" mindsets and corresponding toolset analogies. The one with the moustaches, for example.

PHP got a lot of inspiration from Perl, while missing key concepts (you know this one). However, thanks to web development PHP is currently one of the most popular languages.
What is your honest opinion about PHP? Are there things in PHP, missing in Perl, you regret not having thought about?
Reversely, which Perl features PHP should have taken?

$_

ObPHPlink: A fractal of bad design.

The arguments on PHP noted in http://eev.ee/blog/2012/04/09/... are valid point which show that as a language and framework PHP is a mess.

Yes, PHP has lots of problems, and I couldn't care less. It works very well for me and in my world that's where the rubber meets the road. Sure, PHP has a ton of warts, etc etc etc, and the fact is that I don't care one bit.

-

However, if it serves you to build software with PHP, as you have clients who want that, then this is totally fine. Obviously your customers are willing to pay a lot more for development time than necessary.

The only client I have is me. I build what I want, when I want, the way I want. And so far I've done pretty damn well. I don't know if I'd say that I've been a "smashing success", but I will say that I've done damn well. As I've said, PHP has enabled me to live quite comfortably, travel the world on my schedule, live in a nice home, buy nice cars for my wife and I, support my family very well, make my house payments, etc etc etc. Really, what's not to like about that? :)

The fact is that many of the people dissing on me here secretly wish they could do as well as I have. It's only partially about the language- a lot of the hate is based around the fact that I've used such a "terrible" language to make a ton of money, and that conflicts with their "PHP is teh suck!" paradigm.

The arguments on PHP noted in http://eev.ee/blog/2012/04/09/... are valid point which show that as a language and framework PHP is a mess. This has nothing to do with hate (even though the post sounds like that), it is an honest criticism of the language and framework.

However, if it serves you to build software with PHP, as you have clients who want that, then this is totally fine. Obviously your customers are willing to pay a lot more for development time than necessary. Or you are implementing rather small applications. Most of the criticism targets larger code bases. The larger the code base the more pronounced become all the issues listed in the blog.

The last time I compared Eevee's "fractal" article to ManiacDan's "hardly" rebuttal, I found that PHP's alleged problems fit into two categories: those that can be easily worked around with coding standards, and about a half dozen real issues.

PHP 7 has completely addressed one of the real issues, namely parse errors in include being fatal, by introducing engine exceptions. Function argument and return value type hints add some of the benefits of Python-style strong typing to PHP. And though associativity on ?: is still on the less useful side for reasons of backward compatibility, the new null coalesce operator ?? is on the proper side for chaining.

So it's like PHP, in that it was a fractal of bad flaws that resulted in this disaster?

the PHP code is harder to maintain long term, but it's amazing how fast you can build things that work.

Quick doesn't have to mean dirty. You can be extremely productive without creating unmaintainable crap in an ugly, badly-designed language. It's not a trade-off, you can have a better language and better productivity at the same time.

If the PHP devs would even fix any of these listed here, it would be a improvement.

* PHP: a fractal of bad design

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.

(source)

HTH, HAND

PHP: a fractal of bad design

Some small examples: http://eev.ee/blog/2012/04/09/... and many of http://www.reddit.com/r/lolphp...

PHP really isn't that great...sure, a good programmer could make a site that works well enough with it, but there really are better choices!

http://eev.ee/blog/2012/04/09/php-a-fractal-of-bad-design/

The problem is sometimes you don't even know the beginning of the function, eg is it number_format() or format_number() (or formatnumber etc...). Where can you find a hint when the whole language is inconsistent. it's impossible to follow a logic, a trend, PHP has so many inconsistencies nothing intuitive can be deduced from the existing funcs/structure... enjoy...

I find php to be one of the nicer to use languages

When did PHP stop being "a fractal of bad design", as a well-known essay claims? True, not all points in that essay are valid, but I myself see six categories of valid criticism of PHP.

PHP is far more available in cheap hosting solutions. The apps are simpler to deploy (simply put them along your static html files in a web server that supports its extension), and simple apps are simpler in php. The ecosystem around was not touched in the review, Compose vs npm, joyent vs the community behind php, the future of both platforms.

In the other hand, PHP is (or at least, used to be recently enough) a fractal of bad design

Why don't they 1-index then?

Because they forget to, and because all the algorithms and data structures that they learned elsewhere, such as heap priority queues, have to have their logic changed between 0- and 1-indexing and between arrays that do and do not allow nil to be an element. For example, any SQL database will produce NULL values in the result of a LEFT JOIN statement, but in the iterator protocol used by Lua's for statement, nil is the terminator.

Are they that stupid?

Some people would interpret this question as carrying a hidden assumption that even if a language's design is flawed, a programmer can be just as productive in it as in any other language. If you are not trying to imply that, then yes, programmers are fallible, and a language design can help a programmer produce a correct program more quickly by protecting the programmer from his own mistakes. See, for example, widely cited accusations leveled at PHP. But if you are trying to imply that, then why not just have everybody program in assembly language?

I agree that Rails is a fad. But touting PHP as better is... odd. PHP is a dismal language, with horrible coding practices and duplicate commands (some are bad, some are good, who knows which is which). Using a library, you have no idea what code they used... did they use the old string routine that's vulnerable to buffer overflows, or the new one? Why does PHP even KEEP the broken commands, it's insane!

Ruby is good (despite performance issues), PHP is bad. I'll take any framework built around Ruby over any framework built around PHP.

The vulnerability is in the language parser, not the language design by itself. Imagine that in java (or whatever is a "proper" designed language for you, just that don't be PHP) you put some weird syntax that makes the compiler to execute injected code.

Many of us have read the PHP is a fractal of bad design article and a commonly cited rebuttal. I tried to reconcile the two and ended up with about a half dozen legit complaints.

PHP's list of oddities is never-ending. From "catchable fatal error" to "unexpected T_PAAMAYIM_NEKUDOTAYIM".

There are some nice collections at http://eev.ee/blog/2012/04/09/... http://phpmanualmasterpieces.t... and http://www.phpwtf.org/

Sure, but a programming language should not work AGAINST the programmer, and this is exactly what PHP does.

Take a look at this page, and no, it's not an anti-php rant, but an overview of actual facts about PHP:

http://eev.ee/blog/2012/04/09/...

I made a few PHP projects myself, but since I discovered Python and Django Framework, I would never go back to PHP again.

Nope, it IS the knife...

PHP: Fractal of Bad Design

Asking a developer to use PHP is like asking a carpenter to frame a house using only a pile of twigs and a spoon. You can ask. You can pay for the work. The end product is not going to be very good. However, using PHP, one might end up with a good enough rinky-dink website for a rinky-dink company - and there's your use case for PHP

Let's play Hegelian dialectic: Thesis The "fractal" rant Antithesis The "hardly" rebuttal Synthesis Six identifiable bullet points

Anyone cosidering PHP should read this the now infamouns "PHP is a fractal of bad design".

http://eev.ee/blog/2012/04/09/...

Most of it applies to old, obsolete versions of PHP. That's like complaining about the 640K barrier in Microsoft's operating systems.

Anyone cosidering PHP should read this the now infamouns "PHP is a fractal of bad design".

http://eev.ee/blog/2012/04/09/...

Is that thing still around?

Despite all hatred - and let's face it, PHP is a really strange phenomenon - this is why PHP continues to thrive. The PHP community gets from A to B by the most bizar reroutes across Z, Mary Poppins and f(x)=x^2e^x-2. PHP is a fractal of bad design, but they always seem to focus on the next issue that's simply in the way of getting the next real world job done. I've written a post on that a few weeks ago.

Them checking the performance of Wordpress (one of the large popular CMSes out there, with a really shitty architecture ... like most of its kind) as a benchmark for the foundation of a VM show how 'fast result' oriented the PHP community is. The idea itself of testing like this would seem insane to any serious developer, AFAICT.

Point in case for PHPs insanity that always seems to work out in a strange way:
I've fought it for over 12 years, but now I've finally given in and am working myself into Typo3, a big-league player in the world of PHP Web CMSes. Let me tell you: If you think Wordpress, Drupal or Joomla have an architecture that was designed by chimpansees (I should now, I've deployed Drupal and Joomla professionally and was on the Joomla Bugsquad), Typo3s has one that was designed by amobeas. With TypoScript - the T3 template and config language - they've got the textbook example of an inner platform (think PHP but non-turing complete for configuration and with magic numbers ... sort of like line-numbers, but not quite ... its really crazy ...). If PHP is a fractal of bad design, Typo3 classic is that ^2. It's very difficult to describe, you have to experience it for yourself to fully understand. It's like taking the red and the blue pill at the same time. Seriously.

Anyway, I'm veering off. The point is:
Knowing Typo3 is basically job security galore for any web developer in Germany. Period. I've agreed to dive into T3 and am right now scoring more than 60 Euros an hour. Being able to edit templates in the CMS Admin area isn't bad either. ... Although TypoScript is one of the strangest things I've seen in my 28 years of computing, I have to admit. Think of Typo3 as the Vi and Emacs of CMSes, all rolled into one. Yet there are over 2000 official Typo3 agencies here in Germany. Being an online agency basically means being a Typo3 agency over here. What do you say, it's what people want. T3 is a household brand, it has an official association, a neat website and the vibe of "big, complicated and professional" all over it. The customers want it, and they're willing to pay for deployment in T3. Who am I to complain?

Bottom line:
PHP is bad, and nobody cares. Its barrier of entry is basically non-existant, security issues be damned, and they have a slew of pointy-clicky stuff for the peddlers to sell to end-customers. All for free. The most succesful FOSS projects are written in it and if the PHP crew are going to stick to their crazy "make it work, then make it beautiful" approach, it's probably going to stay that way for a long time.

My 2 cents.

Despite all hatred - and let's face it, PHP is a really strange phenomenon - this is why PHP continues to thrive. The PHP community gets from A to B by the most bizar reroutes across Z, Mary Poppins and f(x)=x^2e^x-2. PHP is a fractal of bad design, but they always seem to focus on the next issue that's simply in the way of getting the next real world job done. I've written a post on that a few weeks ago.

Them checking the performance of Wordpress (one of the large popular CMSes out there, with a really shitty architecture ... like most of its kind) as a benchmark for the foundation of a VM show how 'fast result' oriented the PHP community is. The idea itself of testing like this would seem insane to any serious developer, AFAICT.

Point in case for PHPs insanity that always seems to work out in a strange way:
I've fought it for over 12 years, but now I've finally given in and am working myself into Typo3, a big-league player in the world of PHP Web CMSes. Let me tell you: If you think Wordpress, Drupal or Joomla have an architecture that was designed by chimpansees (I should now, I've deployed Drupal and Joomla professionally and was on the Joomla Bugsquad), Typo3s has one that was designed by amobeas. With TypoScript - the T3 template and config language - they've got the textbook example of an inner platform (think PHP but non-turing complete for configuration and with magic numbers ... sort of like line-numbers, but not quite ... its really crazy ...). If PHP is a fractal of bad design, Typo3 classic is that ^2. It's very difficult to describe, you have to experience it for yourself to fully understand. It's like taking the red and the blue pill at the same time. Seriously.

Anyway, I'm veering off. The point is:
Knowing Typo3 is basically job security galore for any web developer in Germany. Period. I've agreed to dive into T3 and am right now scoring more than 60Ã an hour. Being able to edit templates in the CMS Admin area isn't bad either. ... Although TypoScript is one of the strangest things I've seen in my 28 years of computing, I have to admit. Think of Typo3 as the Vi and Emacs of CMSes, all rolled into one. Yet there are over 2000 official Typo3 agencies here in Germany. Being an online agency basically means being a Typo3 agency over here. What do you say, it's what people want. T3 is a household brand, it has an official association, a neat website and the vibe of "big, complicated and professional" all over it. The customers want it, and they're willing to pay for deployment in T3. Who am I to complain?

PHP is bad, and nobody cares. Its barrier of entry is basically non-existant, security issues be damned, and they have a slew of pointy-clicky stuff for the peddlers to sell to end-customers. All for free. The most succesful FOSS projects are written in it and if the PHP crew are going to stick to their crazy "make it work, then make it beautiful" approach, it's probably going to stay that way for a long time.

My 2 cents.

You mean like this one?
http://eev.ee/blog/2012/04/09/...

All CMSs I've had the pleasure to work with are a nightmare. It's usually a lot harder to get the CMS to do what you want than to just slap together the pages and headers yourself.

As for Drupal specifically, it's written in PHP. I have found through extensive experience that sooner or later you need to dive into the code of the CMS itself, and if you want to change or extend functionality, you also tend to need to code in whatever language the CMS was coded in. So for your own sanity, pick one that's written in something else.

Django, Magnolia, Umbraco, Hippo, ... There's plenty choice, so you don't need to inflict PHP upon yourself.

(If you're unfamiliar with PHP you're probably wondering why I'd consider this the most important requirement. Go read these:
PHP: a fractal of bad design
PHP turtles
There are plenty more sites documenting PHP's failings. I've done a lot of professional development in PHP and I can testify that it's the absolute worst programming language that's still in common use.)