Semantic data semantic layer for software development
could software development become easier if we could build a data semantic layer on top of databases?
what if we could build a data semantic layer on top of logical constructs?
not just reports but a data semantic layer adjusted for the terms that programmers want to see
not just the terms that businesses want to see
this could be an object member semantic layer
This list covers action verbs to think about information in order to create new project ideas. Note that ‘negate’ gets used with other action verbs like ‘hurt’; note that these verbs may be combined.
- Advocate: sell/promote
- Benefit: help/improve
- Create: Build/Develop/Construct
- Decision: Decision Making/Choice/Action
- Effect: Event/Result/Output/end/finish
- Future: planning/prediction
- Govern: manage/handle/guide/control
- Hurt: damage/problem/hazard
- Individualize: Customize/User preference
- Joined: Relationships/interaction
- Keep: settle/fix/be
- Location: physical world
- Modify: change/alter
- Negate X: avoidance/nullification/Negation
- Optimize: Balancing/Resources
- Presentation: Present/Format/Arrange/Layout
- Quanta/data: Data/text/numbers/bits/files/documents/measurements/values
- Receive: Get
- Send: Put/publish
- Technology: Integration/Technology/Interfaces/UIs
- Understand: Learning/Understanding/Knowledge building
- View: Vision/Recognition/spotting/finding/searching/detection
Here are some examples of capabilities that using information provides for a program when used inside an application:
- Allocation: Balancing/distribution/Balancing/resource allocation
- Building AI: Knowledge representation/AI/Data–>Information–>Ontologies->AI.
- Context/metadata: Metadata/Context/Richer metadata.
- Defined data: characterized data/data context/semantic data/soft coded context.
- Evolving systems: Evolution/Genetic Algorithms/Genetic algorithms.
- Fuzzy information: Anti-aliasing data and information.
- Generators: Creation/Creating new things programmatically.
- Handling 0nf: automation/Conflated information handling (0NF).
- Importance/order: Ordering/Importance management/Prioritization.
- Judgment: Action/decision/function/Decision automation.
- Knowledge/Information: Core information functionality above the level of data.
- Languages: Natural language/sub-natural languages.
- Mutual languages for users/humans/computers, HCI creative partnering.
- Networking: Mutual languages for data networking.
- Overlooked possibilities: Thorough coverage/Overlooked possibility identification.
- Information proxies: Information data equivalent/Proxy creation and analysis.
- Query/search: Filtering/search/matching/Filtering, searching, and matching.
- Recognition: Viewing/recognizing/profiles, signature/pattern recognition.
- State management: Status/State/Situation information, complex state management
- Type assimilation: Kinds/bits/assimilating database complexity.
- Using the results of data mining/information persistence/Information storage.
- Viewing systems: Condensing data/sparse data or information UIs.
This is in response to a question asked on Fora Is there a “ceiling” in software engineering? Why?
Software developers hit a glass ceiling because software development itself has hit a glass ceiling. Software development has failed to figure out how to work with information directly inside a computer program. Instead, we work with data rather than information. We have left the information work to the BI, data analytics, data mining, knowledge representation world. This world works with data after the fact to extract information from it.
What if programmers could work with information inside a program? before the fact. The next level of development could be to work with information as well as data inside a program. The glass ceiling is that we generally can not work with information. An entire new industry development effort needs to get started developing tools and techniques for doing this. I am doing my little bit to break through this glass ceiling at my blog. I also provide libraries for the techniques so far developed. But we need much more than a few techniques that one software developer can create, God willing. We need an industry push to break through the glass ceiling and build the entire information level of software development. Let’s get started!
Programming won’t really be complete until we push our software development technology up to level 4.
Level 4 issues:
- ontological meaning/context
The reason we have so much trouble with workflow and layout is that we haven’t built level 4 yet.
build level 3 toward level 4?
| | |
Level 4 UI -------+--+ layout workflow | | | +-- networks
| | | | | | | |
reports --+-------+----+----+---+---+-+-- database
| | | | | | integration
Level 3 | | endemes ------+ | |
| | | | |
| | +-----+-----+------+ |
| | | | |
Level 2 | objects |
| | |
Level 1 data
Wisdom is a Computational Creativity Function. The computer has to create what it is going to do by applying its understanding gained through artificial intelligence.
- Data: (Raw) Red, 184.108.40.206, v2.0
- Information: (Meaning) South facing traffic light on corner of Pitt and George Streets has turned red.
- Knowledge: (Context) The traffic light I am driving towards has turned red.
- Wisdom: (Applied) I better stop the car!
The Example Converted to Levels:
0. Raw Data
1. Stored Data
2. -> Meaning Data types and objects and hard defined structural interpretation
3. -> Meaning Information with structural (and conceptual?) context as meaning
4. -> Meaning knowledge representation with relational context to user
5. -> Context knowledge and what various outcomes and actions mean
6. -> Applied wisdom – stop the car!
Level 6 is computational creativity. The computer has to create an action.
Context and meaning are both built up through multiple levels rather than just being at one level each.