I will say this in my own terms first and I will finish the rest when I am happy with that. This will take a while. When it is finished it will explain the following entity hierarchy which is intended to enable any process to have good universal external data access -
Entities
Attributes
Attribute Classes
Attribute Values
Anything can be viewed as data - even **processes**. Data is an abstraction of "real"
things.
An entity is a collection of single instances of data.
All data is the full collection of entities.
Each single instance shares a collection of attributes with all other instances of the entity.
In a program all data is metadata until the process is active. The program describes the aspects of data which are required to exist at some time during the activity of the process. A process brings defined data to life by using it in the manner which is required within an active application system.
Data can be accessed from any instance of an entity if the particular instance's identity is known.
Record = Read.Record(Entity.Name, Instance.Name) allows access to any instance's record.
This is a once commonly used technique of data access in the procedural world of programming. It is fine for its purpose, and served to allow the implementation of the file access mechanisms to be isolated from the programs. To a programmer, it is intuitive - it clearly states the process to be applied to the program's data. A programmer would read this (in shorthand) as "Get the record defined by the file name and the key"
However, the use of the record returned is to allow access to the attributes of interest within the record. Very often, a process requires access to just a subset of the record - one or two attributes.
There are many reasons that this approach was not ideal. IMHO an overriding reason was that any changes to the layout of the returned record had to be carefully implemented. This was a potential maintenance problem, which in the spirit of Kaizen must be avoided.
A solution to the shortcomings of Read.Record is to read just the attributes of interest instead of the full record.
Data = Read.Attributes(Entity.Name, Attribute.Names, Instance.Name) allows access to attributes of any instance.
I do not think that Read.Attributes is a good name for this process. It implies that some reading of the instance should be done. Rather, I think it is getting the data, which may or may not include reading the "record". And in this case, the Data requested is fully defined by the arguments specified and these three arguments are the attributes which define any data. The process Read.Attributes is the program which can get any defined data. So
Data = Get.Data(Entity.Name, Attribute.Names, Instance.Name) allows access to attributes of any instance.
--------------------------------------------------------------------------------------------------------------------------------------------
If I were to view the dog, Charlie, as a member of the group called Dogs, I would be treating her as a datum of the data group Dogs.
Her categorization as a Dog implies characteristics shared with all other Dogs
Data is/are data.
Data is the plural of datum.
Data are datums.
That sounds like nonsense, I know. Consider a single datum - what is it?
Is it one little piece of data? Yes. It is one individual piece of
data.
If we were talking about the universe as data, we would intuitively
recognize that the universe is a single thing which contains, well,
everything. But data is just the plural of datum, so what would the
datum be - for the universe's data?
If the universe were viewed as a collection of galaxies, the datum would be a galaxy.
OK - so a galaxy is a datum in the universe.
Data has a life span.
Short term - for the life of an active process
This is volatile data, usually represented as variables.
Medium term - for a life beyond the activity of one process
This is volatile data returned to the calling process.
Long term - for a life beyond the activity of one process and
its callers. This is Database data
Entities
Attributes
Attribute Classes
Attribute Values
Data
Datum
Attributes
A datum is the collection of attribute values that make up any member of the available data.
Entities
Instances
Attributes
An instance is the collection of attribute values that make up an individual member of the particular entity.
Entities(Entity Name, Entity Class, Attribute Names
Instances(Instance Id, Attribute Values)
Data which originates in human interaction requires processing to convert it into a suitable internal format for use in processes. When a person enters a date, it is eventually converted into a standard internal date format, where it may then be further processed. Data is read from the user then converted appropriately before passing to the data processing environment. Of course, the converse is also true - data in internal format is converted appropriately then passed to the user.
Coincidentally, there is a standard way of accessing data in common usage called SQL. Structured Query Language is oddly not just a query language. It is a data management language - it can be used to update and query data. SQL's data can be conceived of as entities containing instances of attribute values. In SQL, the terminology for this would be tables containing rows of attributes.
Whatever the data management language, data is stored as attribute values. A user may have entered a date of 9/9, then the 9th of September, 2011 would be stored as an attribute value in the same format as all other dates in the application system.
This is an aside (the science of SQL includes the term "query". Oddly enough,a query can also update data, insert new data, remove data, create an entity, import or export data to other data management languages etc. In other words, the IT industry misuses the word in one place, and compensates for the misuse by using it in a "technical sense" at the very base of SQL's language definition. This is one of the better examples of the IT industry abusing the English language - I reckon it could be a sub-conscious urge to obfuscate to keep programming for programmers.)
QUEL Language:
create student(name = c10, age = i4, sex = c1, state = c2)
range of s is student
append to s (name = "philip", age = 17, sex = "m", state = "FL")
retrieve (s.all) where s.state = "FL"
replace s (age=s.age+1)
retrieve (s.all)
delete s where s.name="philip"
SQL Language:
create table student(name char(10), age int, sex char(1), state char(2))
insert into student (name, age, sex, state) values ('philip', 17, 'm', 'FL')
select * from student where state = 'FL'
update student set age=age+1
select * from student
delete from student where name='philip'
Cacophony Language:
Save Data("Students", "Name, Age, Sex, State", "", "philip,17,m,FL")
For Each Student in Select Data("Students", "Where State = 'FL'")
Age = Get Data("Students", "Age", Student)
Age += 1
Save Data("Students", "Age", Student, Age)
Next Student
For Each Student in Select Data("Students", "Where Name = 'Philip'")
Delete Data("Students", "", Student)
Next Student
Uploading ....