If you have ever struggled with a configuration file that started to look suspiciously like a programming language, or a JSON blob that required its own parser, you have been living in the ghost of John McCarthy. A new essay by Nirmal Utwani, currently circulating on Hacker News, posits that the historical distinction between code and data is not just blurring—it is effectively dead. The piece uses McCarthy, the inventor of Lisp and the man who coined the term 'Artificial Intelligence,' as the anchor for a broader argument about how modern developer infrastructure treats executable logic and static information as interchangeable primitives.

The Homogeneity Principle in Practice

Utwani’s analysis focuses on the technical implications of Lisp’s original design philosophy, where code and data share the same representation. While this was a theoretical curiosity in the 1950s, the essay argues it is the operational standard for the modern stack. We see this in the way Infrastructure as Code (IaC) tools like Terraform and Pulumi manipulate cloud resources using the same syntax and tooling as application logic. The 'code' that defines a server is treated by the compiler and the runtime exactly like the 'data' that populates it. The article suggests that this shift has forced a redesign of developer tools. We no longer write static configurations; we write programs that emit data. The essay points out that this creates a feedback loop where data models must be executable to be useful, and code must be introspectable to be maintainable. For the builder, this means the mental model of 'this is logic, this is input' is obsolete. Your database schema is a program; your Kubernetes manifest is a data structure that can be manipulated by other programs.

Why This Matters for Your Stack

For developers building or choosing infrastructure tools, the collapse of this divide changes the evaluation criteria. The essay implies that tools which enforce a strict separation between configuration and logic are fighting a losing battle against the current of computer science history. Instead, the winners are tools that offer 'programmable data'—systems that allow you to transform, validate, and execute your configuration files with the same rigor you apply to your application code. This is why we see the rise of DSLs (Domain Specific Languages) that are actually just general-purpose languages in disguise.

Key Takeaways

  • The distinction between code and data is a historical artifact, not a technical necessity, and modern dev tools are rapidly abandoning it.
  • John McCarthy’s Lisp was the first major system to prove that treating code as data enables powerful metaprogramming and dynamic behavior.
  • Modern infrastructure tools (IaC, Config Management) effectively treat all configuration as executable code, requiring developers to apply software engineering best practices to their 'data'.
  • The 'homogeneity principle' means that if you can serialize it, you can program it; if you can program it, it is data.

The Bottom Line

Stop treating your config files as second-class citizens. The code-data divide is a legacy concept, and if your dev tools don't let you treat your data with the same power as your code, you are building on quicksand.