PHP is NOT Just Fine

Published 2020-05-24

My friend and ex-teammate Dwain recently wrote “PHP is just fine”, and when I read that article I initially had a strong reaction of disagreement. After thinking (and starting to write) about it a little more, I don’t disagree so strongly but I still disagree.

PHP is an OK language to use in cases such as maintaining legacy software, contributing to existing ecosystems like WordPress, and perhaps small projects or simple prototypes. However, our software industry is young and evolving quickly, and a “PHP is just fine” attitude ignores all the progress we’ve made over the years.

Choosing the Familiar

In the second paragraph Dwain writes:

“It takes a long time to learn how to use a tool effectively. This leads programmers to use a familiar language when they are confronted with building something new.”

If you’re putting together a small project that only you will be working on, then by all means choose your favorite language. However, if you intend to build something bigger and collaborate with people, then your comfort is not the top priority:

  • If you’re developing software for the data science community you might want to consider Python
  • If you’re developing enterprise software then Java or C# might be a good choice
  • If you’re doing things in the Kubernetes world you might want to use Go
  • If you’re building a WordPress plugin you might want to consider C++ (just kidding, use PHP in this situation)

Additionally, “it takes time to learn new things” is not a good reason to stick with one language. This brings me to my next point:

Learning new Things is Hard

The software industry as a whole is moving so fast, and as professionals in this industry it’s our duty to keep up to date with the latest thoughts and progress. You wouldn’t be too happy if an electrician wired your house according to 1950 standards and said “this is just fine”.

Of course, sometimes it feels like if we tried to keep up to date with everything, we’d fail and still have no time to build anything useful. I totally agree with that. New things are constantly popping up, and many of them may not even survive. But here we have to strike the balance of continuing to educate ourselves while staying productive.

COBOL is Alive and Well

“…but in the midst of all this, COBOL is still alive and is being used by many financial institutions.”

I wouldn’t say COBOL is alive and well. It’s definitely still being used, but primarily in legacy systems. There is a big difference in a language thriving and begrudgingly using it because we have to.

There’s a saying that no programming language ever completely dies. Even if only a few dozen things get built in a language, there’s a very good chance that it’s still running somewhere on a legacy system. This is similar to protocols such as DNS and email (SMTP/POP). These protocols were not designed for security and billions of users, and if we were designing them today they would be completely different. But we’re stuck with them, not because they’re perfect, but because they’re hard to replace.

I don’t think there are many situations where a developer should consider building a new project in COBOL. PHP is not as outdated as COBOL, but I think a similar (but weaker) sentiment applies. Even when it comes to foundational languages such as C and C++, I recently heard this very interesting argument from one of the founders of Let’s Encrypt. He argues that we need to move away from C and C++ if we want a more secure web in the future.

Conclusion

Most programming languages never really completely die out. Sometimes they are running on legacy systems that we can’t change or replace, and other times it’s too risky or expensive to do so. For this reason, there wll always be a place for these languages, and as they lose popularity they will also become lucrative opportunities for specialized developers.

However, I don’t think we can argue that these older tools and languages are just as good as their successors. As our industry evolves, we create new tools, languages and paradigms. They build on and learn from our previous mistakes. They also cover scenarios that may not have even existed when older tools were created.

For these reasons, PHP is NOT just fine :-)

comments powered by Disqus