Can a programming language have too much functionality?

Daniel Jonsson

Daniel Jonsson

— 1 min read

On November 11, .NET 10 was released. Every November, a new version of .NET is released. It came with new functionality in C#, which I'm looking forward to use. Every year, .NET and C# become more capable, with more features and better ways of doing things.

But as a contrast, I recently listened to a presentation from an Elixir conference. The speaker recommended that all project managers visit the Vasa Museum in Stockholm to learn what happens when you add too much functionality to your product. The ship sank from its own weight after they added too many cannons and decorations, and that was his previous experience of being a Java developer. Perhaps there's some truth to that?

I also find it amusing how programming languages are increasingly converging by copying features from each other. On November 20, PHP 8.5 was released, and among the new features is a pipe operator. Previously, you called nested functions like this:

$input = " hello world ";
$result = strtoupper(
  str_replace(" ", "-", 
    trim($input)
  )
);
// Output: "HELLO-WORLD"

But now in PHP you can also write it in this way and get the same result:

$input = " hello world ";
$result = $input
  |> trim(...)
  |> (fn($str) => str_replace(" ", "-", $str))
  |> strtoupper(...);
// Output: "HELLO-WORLD"

The pipe operator makes the code more readable by transformations being read from top to bottom, instead of being read from inside and out.

The pipe operator has long existed in several functional languages. One example is Elixir:

input = " hello world "
result = input
  |> String.trim()
  |> String.replace(" ", "-")
  |> String.upcase()
# Output: "HELLO-WORLD"

Another example is F#:

let input = " hello world "
let result = 
  input
  |> (fun (s: string) -> s.Trim())
  |> (fun (s: string) -> s.Replace(" ", "-"))
  |> (fun (s: string) -> s.ToUpper())
// Output: HELLO-WORLD

There's a proposal to add the pipe operator to JavaScript as well. But we'll see if that becomes reality one day.

As I said, it's somewhat fun to observe that many programming languages are becoming increasingly similar to each other. And I wonder if there's any potential issue with adding "too much" features to a programming language, or if there's value in keeping the feature set intentionally small?

Read more