Where things are and how to access them, is of the essence in both the practical machine world of programming and technology, as well as within conceptualization of I.T. methodologies.
As such, HANDLES and POINTER addressing - not those Turkish delights stuffed inside your Thanksgiving bird, but rather, the method by which programmers utilize structural mnemonics within machines to allow for the assignment, accessibility, and processing of data to be performed as painlessly as possible, render some of our most prized automations.
So OMNITEKK, just what are POINTERS and HANDLES, and how do they work?
So glad you asked my friend... Let's "undress" such a concept shall we.
In the world of both functional and object oriented programming, POINTERS or object addresses, serve as the indexing means of accessing and computing or processing data values, both primitive, and user - defined, within your development environment.
These objects, or values might be functions, data types, structures, as well as volatile instances of file addresses declared, both at program run time or compilation.
So essentially, just as our neighbor's or family members know us by our name, POINTERS act as both explicit and implicit naming conventions, adorned with accessing and communicating with data objects within an application.
Likewise, each time an application runs, while the internal or programmer designated naming conventions of objects - POINTERS also, appear the same, the machine compilations of programmer defined names, are assigned new or different addresses, giving credence to the commonality of POINTERS being coined DYNAMIC ADDRESSING MODES.
Now on to the fun stuff - handler or HANDLE addressing - and no, OMNITEKK isn't referring to the ones from your run of the mill Friday night Martin Scorsese film, although the effects of such an I.T. concept prove oddly similar...
...however we digress, so let us continue shall we?
The main difference between POINTER addressing and HANDLES, is that HANDLES are usually static addressing methods, designed to access objects whose positional location within machines, or on storage medium doesn't necessarily prove itinerant, such as with files stored on tapes, hard drives, or disks, along with all other machine hardware storing information whose locational attributes prove a higher level of finality as opposed to volatility.
For instance, the addressing schemes of select data functions and variables within your application are dynamic, as each run iteration of your program assigns the internal program data structures new addresses, while the addresses of your actual stored program itself, is accessed by a HANDLE, as - while the attributes of the program, such as program file size, might grow or shrink as the program is modified, the housed file location of the application on disk remains the same, thus giving credence to the notion of a HANDLE accessor, versus a POINTER accessor.
A few take aways of note on POINTERS and HANDLES in helping you differentiate between the two is -
POINTERS are known as dynamic accessor types, while HANDLES are known as static types.
POINTERS usually reference things like data whose objects prove volatile, such as the assignment of data value objects which are destroyed upon program end, like structure addresses, and function addresses, while HANDLES typically reference static objects, such as data stored on tapes, drives, or disks, such as those rendered by your file system's page tables, or some other internal addressing scheme to access objects or data members where their accessor means prove higher permanence.
And there you have it folks, OMNITEKK'S rendition of the essential data access object definitions of I.T's glorious POINTERS and HANDLES.
And until our next I.T. adventure my friends, OMNITEKK says be well.
