Inner-Platform Effect

Source: Hacker News

Inner‑Platform Effect

The inner‑platform effect is the tendency of software architects to create a system so customizable that it becomes a replica—often a poor replica—of the software development platform they are using. This results in inefficient solutions and such systems are frequently cited as examples of an anti‑pattern.

Examples

• Plug‑in‑based software – Many text editors and web browsers let developers create plug‑ins that replicate functionality normally provided by the operating system.
  For example, the Firefox add‑on mechanism has been used to build FTP clients and file browsers, effectively reproducing some OS features on a more restricted platform.

• Database “EAV” anti‑pattern – Some developers try to bypass the RDBMS by storing everything in a single table with three columns (entity_id, key, value).
  While the entity‑attribute‑value model frees you from the rigid schema of an SQL database, it also discards many of the database’s advantages: queries become convoluted, the indexes and query optimizer can’t work effectively, and data validity constraints are no longer enforced. The result is usually poor performance and maintainability.

• Over‑generic XML – Developers sometimes use generic element names (e.g., <generic>) and store meaningful data in attributes such as type and value.
  This forces the need for “joins” across multiple attributes to extract meaning, making XPath expressions more complex, evaluation slower, and structural validation of limited benefit.

• Web desktops – A whole desktop environment—often including a web browser—can run inside a browser, which itself typically runs within the desktop provided by the operating system.
  A “desktop‑within‑desktop” is awkward for users and is generally employed only to run programs that cannot be easily deployed on end‑user systems, or to hide the outer desktop away.

Effect

It is normal for software developers to create a library of custom functions that relate to their specific project. The inner‑platform effect occurs when this library expands to include general‑purpose functions that duplicate functionality already available as part of the programming language or platform.

Since each of these new functions usually calls a number of the original functions, they tend to be slower and, if poorly coded, less reliable as well. Citation needed.

On the other hand, such functions are often created to present a simpler (and often more portable) abstraction layer on top of lower‑level services that:

• have an awkward interface,
• are too complex,
• are non‑portable or insufficiently portable, or
• simply are a poor match for higher‑level application code.

Appropriate Uses

An inner platform can be useful for portability and privilege separation—in other words, it allows the same application to run on a wide variety of outer platforms without affecting anything outside a sandbox managed by the inner platform.

For example, Sun Microsystems designed the Java platform to meet both of these goals.

See also

• End‑to‑end principle
• Greenspun’s tenth rule
• Abstraction inversion
• Conway’s law
• Not invented here
• Plain old Java object
• Second‑system effect
• Zawinski’s law of software envelopment

References

1. Celko, Joe (1 February 2011). “Look‑up Tables in SQL.” Simple Talk.
   Archived from the original on 23 September 2016. Retrieved 25 April 2016.

2. Peterson, Don (8 September 2004). “Lookup Table Madness.” SQL Server Central.
   Retrieved 1 May 2023.

External links

• Original definition and example – The Daily WTF: The Inner‑Platform Effect
• Example: The Enterprise Rules Engine – The Daily WTF article
• Example: “I Think I’ll Call Them ‘Transactions’” – The Daily WTF article
• Anti‑Patterns: Refactoring Software, Architectures, and Projects in Crisis – William J. Brown et al., see the Wiki page: /wiki/AntiPatterns