Skip to content
TheChatArchiveThe Chat Archive
grok-3-preview-02-24· xAIHugging Face LMArena Human Preference 140K

There is a fairly famous blog article about some software firm (or traditional…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Metallama-4-maverick-17b-128e-instruct’s answer.
  1. User

    There is a fairly famous blog article about some software firm (or traditional business's software department) starting out with a wish to make some of their business rules configurable, then that config grows more complex so they use XML or whatever, then there comes a need for some of the configuration to contain a bit of logic so they add that, then eventually they end up with a giant monstrous "fully generic business rules engine" that's a (bad) programming language in its own right. And I think it also referenced a project so solve this "write an XML business rules engine" problem once and for all by writing THE generic XML business rules engine, not tied to any specific business, and sell it to businesses, which was an even bigger nightmare. But I can't find it anymore. Do you know the one I have in mind? What's its title and where do I find it?

  2. Assistant

    You're likely referring to a classic blog post or article discussing the pitfalls of over-engineering configuration systems, particularly in the context of business rules engines, XML, and the creation of "accidental" domain-specific languages (DSLs). The scenario you describe—starting with simple configuration, escalating to complex XML, adding logic, and eventually building a monstrous, unmaintainable system—is a well-known cautionary tale in software engineering.

    Based on your description, the article you're thinking of might be "The Configuration Complexity Clock" by Dan North (also known for his work on Behavior-Driven Development, or BDD). While this specific post doesn't focus exclusively on XML or business rules engines, it describes a similar progression of complexity, where systems start simple but grow into unmanageable beasts as more features, configurability, and abstractions are added. The "clock" metaphor illustrates how teams often cycle through stages of complexity, eventually reaching a point of absurdity (like building a generic, all-purpose rules engine).

    However, if this isn't the exact post you're thinking of, there are a few other possibilities:

    1. "Things You Should Never Do, Part I" by Joel Spolsky (Joel on Software)

      • This classic article discusses the dangers of rewriting systems from scratch, but it also touches on the perils of over-abstracting and over-generalizing systems, which could lead to the kind of "generic business rules engine" nightmare you describe. While not specifically about XML or business rules, it might be related to the theme you're recalling.
    2. "XML: The Angle Bracket Tax" or similar rants

      • There are several famous blog posts and articles from the early 2000s that critique the overuse of XML, especially in business rules engines and configuration systems. Authors like Ted Neward (who coined the term "XML Hell") or Erik Meijer have written about the dangers of XML-based systems growing into unmaintainable monstrosities, often with logic embedded in XML, leading to what is effectively a poorly designed programming language.
    3. "The Law of Leaky Abstractions" by Joel Spolsky

      • Another Joel on Software classic, this post discusses how abstractions (like a generic business rules engine) often fail to hide complexity and instead create new, worse problems. While not specifically about XML or business rules, it might resonate with the themes you're recalling.
    4. A Martin Fowler Article or Book Reference

      • Martin Fowler, in his writings on enterprise software (e.g., Patterns of Enterprise Application Architecture or his blog), has discussed the dangers of over-engineering business rules systems, including the creation of generic rules engines that become unmaintainable. His work often references real-world examples of such systems spiraling out of control.
    5. A Post on "Inner-Platform Effect"

      • The "inner-platform effect" is a term used to describe systems that try to be so generic and configurable that they essentially reinvent an entire platform or programming language, but poorly. This concept is often discussed in the context of business rules engines, XML configuration, and enterprise software. While not tied to a single famous post, this term might help you find the article you're looking for.

    The Generic XML Business Rules Engine Project

    The second part of your description—about a project to create the generic XML business rules engine, meant to be sold to businesses—sounds like a critique of real-world enterprise software trends in the early 2000s. During that era, many companies (e.g., IBM, Oracle, and others) marketed "business process management" (BPM) or "business rules management systems" (BRMS) that promised to let non-technical users define complex business logic via XML, graphical interfaces, or custom DSLs. These systems often became nightmarish to maintain, as they were neither as flexible as real programming languages nor as simple as the marketing promised. This critique is a common theme in software engineering blogs from that time, but it might not be tied to a single famous post.

    How to Find the Article

    If none of the above are the exact article you're looking for, here are some steps to help you locate it:

    1. Search for Key Terms

      • Try searching for phrases like:
        • "XML business rules engine nightmare"
        • "generic business rules engine failure"
        • "configuration complexity business rules"
        • "accidental programming language XML"
        • "inner-platform effect business rules"
      • Use Google with time filters (e.g., posts from 2000–2010) to narrow down to the era when XML and business rules engines were hot topics.
    2. Check Classic Software Engineering Blogs

      • Look through archives of well-known blogs from the era, such as:
        • Joel on Software (joelonsoftware.com)
        • Martin Fowler's Blog (martinfowler.com)
        • Dan North's Blog (dannorth.net)
        • The Daily WTF (thedailywtf.com) – This site often features horror stories about over-engineered systems, including XML-based rules engines.
        • Coding Horror by Jeff Atwood (codinghorror.com)
    3. Ask in Communities

      • Post a description of the article on forums like Stack Overflow, Reddit (e.g., r/programming or r/softwaredevelopment), or Hacker News. Someone might recognize it.
    4. Check Books or Papers

      • If the article referenced a specific failed project or product, it might be mentioned in books like The Mythical Man-Month by Fred Brooks, Peopleware by Tom DeMarco and Timothy Lister, or Enterprise Integration Patterns by Gregor Hohpe and Bobby Woolf. These books often discuss the pitfalls of over-engineering and generic systems.

    If It's "The Configuration Complexity Clock"

    If Dan North's "The Configuration Complexity Clock" is indeed the article you're thinking of, you can find it on his blog, dannorth.net. If the original post is no longer available, it might be archived on the Wayback Machine (archive.org). Search for "Dan North Configuration Complexity Clock" to locate it.

    Final Thoughts

    If none of these suggestions match the article you're looking for, it's possible the post was from a less well-known blog or has been taken offline. In that case, the search terms and community resources above should help you track it down. If you remember any additional details (e.g., the author's name, the era it was published, or specific phrases from the article), let me know, and I can refine the search further!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.