Information management

Information management (IM) is primarily concerned with the capture, digitization, representation, organization, transformation, and presentation of information. Because a computer’s main memory provides only temporary storage, computers are equipped with auxiliary disk storage devices that permanently store data. These devices are characterized by having much higher capacity than main memory but slower read/write (access) speed. Data stored on a disk must be read into main memory before it can be processed. A major goal of IM systems, therefore, is to develop efficient algorithms to store and retrieve specific data for processing.

IM systems comprise databases and algorithms for the efficient storage, retrieval, updating, and deleting of specific items in the database. The underlying structure of a database is a set of files residing permanently on a disk storage device. Each file can be further broken down into a series of records, which contains individual data items, or fields. Each field gives the value of some property (or attribute) of the entity represented by a record. For example, a personnel file may contain a series of records, one for each individual in the organization, and each record would contain fields that contain that person’s name, address, phone number, e-mail address, and so forth.

Many file systems are sequential, meaning that successive records are processed in the order in which they are stored, starting from the beginning and proceeding to the end. This file structure was particularly popular in the early days of computing, when files were stored on reels of magnetic tape and these reels could be processed only in a sequential manner. Sequential files are generally stored in some sorted order (e.g., alphabetic) for printing of reports (e.g., a telephone directory) and for efficient processing of batches of transactions. Banking transactions (deposits and withdrawals), for instance, might be sorted in the same order as the accounts file, so that as each transaction is read the system need only scan ahead to find the accounts record to which it applies.

With modern storage systems, it is possible to access any data record in a random fashion. To facilitate efficient random access, the data records in a file are stored with indexes called keys. An index of a file is much like an index of a book; it contains a key for each record in the file along with the location where the record is stored. Since indexes might be long, they are usually structured in some hierarchical fashion so that they can be navigated efficiently. The top level of an index, for example, might contain locations of (point to) indexes to items beginning with the letters A, B, etc. The A index itself may contain not locations of data items but pointers to indexes of items beginning with the letters Ab, Ac, and so on. Locating the index for the desired record by traversing a treelike structure is quite efficient.

Many applications require access to many independent files containing related and even overlapping data. Their information management activities frequently require data from several files to be linked, and hence the need for a database model emerges. Historically, three different types of database models have been developed to support the linkage of records of different types: (1) the hierarchical model, in which record types are linked in a treelike structure (e.g., employee records might be grouped under records describing the departments in which employees work), (2) the network model, in which arbitrary linkages of record types may be created (e.g., employee records might be linked on one hand to employees’ departments and on the other hand to their supervisors—that is, other employees), and (3) the relational model, in which all data are represented in simple tabular form.

In the relational model, each individual entry is described by the set of its attribute values (called a relation), stored in one row of the table. This linkage of n attribute values to provide a meaningful description of a real-world entity or a relationship among such entities forms a mathematical n-tuple. The relational model also supports queries (requests for information) that involve several tables by providing automatic linkage across tables by means of a “join” operation that combines records with identical values of common attributes. Payroll data, for example, can be stored in one table and personnel benefits data in another; complete information on an employee could be obtained by joining the two tables using the employee’s unique identification number as a common attribute.

To support database processing, a software artifact known as a database management system (DBMS) is required to manage the data and provide the user with commands to retrieve information from the database. For example, a widely used DBMS that supports the relational model is MySQL.

Another development in database technology is to incorporate the object concept. In object-oriented databases, all data are objects. Objects may be linked together by an “is-part-of” relationship to represent larger, composite objects. Data describing a truck, for instance, may be stored as a composite of a particular engine, chassis, drive train, and so forth. Classes of objects may form a hierarchy in which individual objects may inherit properties from objects farther up in the hierarchy. For example, objects of the class “motorized vehicle” all have an engine; members of the subclasses “truck” or “airplane” will then also have an engine.

NoSQL, or non-relational databases, have also emerged. These databases are different from the classic relational databases because they do not require fixed tables. Many of them are document-oriented databases, in which voice, music, images, and video clips are stored along with traditional textual information. An important subset of NoSQL are the XML databases, which are widely used in the development of Android smartphone and tablet applications.

Data integrity refers to designing a DBMS that ensures the correctness and stability of its data across all applications that access the system. When a database is designed, integrity checking is enabled by specifying the data type of each column in the table. For example, if an identification number is specified to be nine digits, the DBMS will reject an update attempting to assign a value with more or fewer digits or one including an alphabetic character. Another type of integrity, known as referential integrity, requires that each entity referenced by some other entity must itself exist in the database. For example, if an airline reservation is requested for a particular flight number, then the flight referenced by that number must actually exist.

Access to a database by multiple simultaneous users requires that the DBMS include a concurrency control mechanism (called locking) to maintain integrity whenever two different users attempt to access the same data at the same time. For example, two travel agents may try to book the last seat on a plane at more or less the same time. Without concurrency control, both may think they have succeeded, though only one booking is actually entered into the database.

A key concept in studying concurrency control and the maintenance of data integrity is the transaction, defined as an indivisible operation that transforms the database from one state into another. To illustrate, consider an electronic transfer of funds of $5 from bank account A to account B. The operation that deducts $5 from account A leaves the database without integrity since the total over all accounts is $5 short. Similarly, the operation that adds $5 to account B in itself makes the total $5 too much. Combining these two operations into a single transaction, however, maintains data integrity. The key here is to ensure that only complete transactions are applied to the data and that multiple concurrent transactions are executed using locking so that serializing them would produce the same result. A transaction-oriented control mechanism for database access becomes difficult in the case of a long transaction, for example, when several engineers are working, perhaps over the course of several days, on a product design that may not exhibit data integrity until the project is complete.

As mentioned previously, a database may be distributed in that its data can be spread among different host computers on a network. If the distributed data contains duplicates, the concurrency control problem is more complex. Distributed databases must have a distributed DBMS to provide overall control of queries and updates in a manner that does not require that the user know the location of the data. A closely related concept is interoperability, meaning the ability of the user of one member of a group of disparate systems (all having the same functionality) to work with any of the systems of the group with equal ease and via the same interface.

Intelligent systems

Artificial intelligence (AI) is an area of research that goes back to the very beginnings of computer science. The idea of building a machine that can perform tasks perceived as requiring human intelligence is an attractive one. The tasks that have been studied from this point of view include game playing, language translation, natural language understanding, fault diagnosis, robotics, and supplying expert advice. (For a more detailed discussion of the successes and failures of AI over the years, see artificial intelligence.)

Since the late 20th century, the field of intelligent systems has focused on the support of everyday applications—e-mail, word processing, and search—using nontraditional techniques. These techniques include the design and analysis of autonomous agents that perceive their environment and interact rationally with it. The solutions rely on a broad set of knowledge-representation schemes, problem-solving mechanisms, and learning strategies. They deal with sensing (e.g., speech recognition, natural language understanding, and computer vision), problem-solving (e.g., search and planning), acting (e.g., robotics), and the architectures needed to support them (e.g,. agents and multi-agents).