In figuring out how to work with information inside a computer program, I am working toward building an inner platform. The thing I have to watch out for is an anti-pattern called the “Inner Platform Effect”. The inner platform effect often starts out with a generic database that gets added to and enhanced until it becomes a replica (usually a poor and incomplete one) of one of the systems that it is built on top of. Most often the kinds of inner platforms built are replications of relational databases and operating systems.
It is possible to build an inner platform that replicates the capabilities and organization of a relational database. It is possible to build an inner platform that replicates the capabilities and organization of an operating system. It is possible to build an inner platform that replicates the capabilities and organization of an object oriented software development system.
In data oriented software development the inner platform effect is an anti-pattern. The Inner Platform Effect – “The Inner-Platform Effect is a result of designing a system to be so customizable that it ends becoming a poor replica of the platform it was designed with.” This “customization” of this dynamic inner-platform becomes so complicated that only a programmer (and not the end user) is able to modify it.
Three things tend to lead to the creation of an inner platform
- Users want something that they can modify themselves without having to have a programmer involved.
- Programmers want to build something very generic because they do not know what precise needs their user have.
- Programmers may realize deep down that the way forward in software development is to build a level above the level they are currently working. This may be the real reason programmers keep building them and suffering the consequences. Without information structures and theory, you simply can not build an inner platform that has added more capability than a database or object oriented approach. Any or all of these may be in play.
- Programmers look at repetitive field handling code and think to themselves that there must be a way of abstracting it. You see (to oversimplify the situation) each column in a table ends up being a member in a class. A whole bunch of members tend to look the same, get set, changed and erased and displayed the same way, and the thinking is that there really should be a generic abstracted way to handle them.
Avoid the Inner Platform Effect
When you are building an inner platform there are some things you can do to avoid the inner platform effect:
- Do something the underlying platform cannot do or can do very poorly. This is my goal – to build an inner platform that works with information as well as data.
Working with information is something that a database or an object oriented programming can barely do if at all. Usually when someone attempts to use one of these technologies for information, they end up with a snarl of excessively complex, nearly unmaintainable code.
– Endemes provide work-with-able information about the items in the ‘inner platform’. Information about the items is what inner platforms are normally missing.
- For simple information: avoid objects and attributes in the endeme tables. have only endeme strings, labels and ids
- have the endeme id’s in the tables (objects) directly
- the endeme is the value
- for endemized attributes/data:
avoid objects in the endeme tables, each endeme for the data is its attribute
– the endeme is the attribute, the endeme’s value is the data, the label is the name of the attribute
- for endemeized objects: This would be a generic database and full inner platform.
I don’t know how to avoid building an inner platform here. I need much more experience working with 1,2,ad 3. above before I can hope to work with endemized
objects without suffering the inner platform effect. The trick is, that in order to get this experience, I need to build a bunch of inner platforms, have them die their expected gory death due to the inner platform effect, and eventually figure out how to build a true information programming platform that does not suffer this.
need to use level 4, can not do this properly until level 3 is well understood
this would build an actual inner platform.
– endeme lists would avoid the problem of not using the database for some of its excellent features.
this is because the database would need to support custom indexes, (since information has no order) and functions and triggers to power those indexes, (since the database does these very well)
- Level 4 programming will be based on an inner platform. We need to build an inner platform for level 4 information programming. This will allow us to use knowledge representation in programming. Note to self: look to see if there are any successful knowledge representation inner platforms out there. OWL comes to mind.
- AI programming will be based on the knowledge representation programming and is possible once an inner platform is built for level 4 programming. The inner model has a column for id, key/field, and value.
More thoughts on avoiding the inner platform effect
- how do I avoid the inner platform effect?
- keep the inner platform really sparse in features
- do a hybrid system
- have columns for id(must have), field(in only its information format), and value(must have)
- access by information, not ‘table’ and ‘key’
- but an endeme list has endemes with labels, access by information, the endeme makes it different
- have no search attributes, put these in regular table columns
- don’t let a user modify it, only for programmers
- build a solid infrastructure to hide the implementation details
- implement in really slow steps, taking years and learning how to do each step well before moving on to the next one
- how do I use the RDB for what it’s good for?
- the question is what can I do with information?
Building a Successful Inner Platform
The inner platform effect is an intuition by programmers that we need to build a level above the data levels. However without the information oriented programming theory to base it on, inner platforms just generally only implement things that already exist. Thus they usually fail to build a level above data levels.
I want to take the inner platform above both the database, the OS and the object oriented program level. The challenge is to have the inner platform reach out to the rel platform it replaces to use the performance facilities of the real platform below. The inability of an inner platform to do this is the most common downfall for the inner platform.
An inner platform for a database:
An inner platform for object orientation/xml/json:
An inner platform for an operating system:
Generic Data Models
– object attribute value
From C2: Definitely not an anti-pattern, and it can often greatly simplify table design for some corner scenarios. Apart from giving rapid prototyping benefits it also helps with handling ‘jagged’ data. Instead of introducing null columns using GenericDataModel enables us to save only relevant data thereby actually decreasing complexity. Reporting and manual labor against the table can be handled via views as mentioned above. not
- The entity: the item being described.
- The attribute or parameter: typically implemented as a foreign key into a table of attribute definitions. The attribute definitions table might contain the following columns: an attribute ID, attribute name, description, data type, and columns assisting input validation, e.g., maximum string length and regular expression, set of permissible values, etc.
- The value of the attribute.
From Wikipedia: As noted above, EAV modeling makes sense for categories of data, such as
– clinical findings, where attributes are numerous and sparse.
Where these conditions do not hold, standard relational modeling (i.e., one column per attribute) is preferable; using EAV does not mean abandoning common sense or principles of good relational design. In clinical record systems, the subschemas dealing with patient demographics and billing are typically modeled conventionally. (While most vendor database schemas are proprietary, VistA, the system used throughout the United States Department of Veterans Affairs (VA) medical system, known as the Veterans Health Administration (VHA), is open-source and its schema is readily inspectable, though it uses a MUMPS database engine rather than a relational database.)
We Need an Inner Platform for Information
We need an inner platform because the db and the language do not provide what we need and we need a platform that will.
the problem is based on members