scispace - formally typeset
Search or ask a question

Showing papers in "ACM Computing Surveys in 1996"


Journal ArticleDOI
TL;DR: Machine learning addresses many of the same research questions as the fields of statistics, data mining, and psychology, but with differences of emphasis.
Abstract: Machine Learning is the study of methods for programming computers to learn. Computers are applied to a wide range of tasks, and for most of these it is relatively easy for programmers to design and implement the necessary software. However, there are many tasks for which this is difficult or impossible. These can be divided into four general categories. First, there are problems for which there exist no human experts. For example, in modern automated manufacturing facilities, there is a need to predict machine failures before they occur by analyzing sensor readings. Because the machines are new, there are no human experts who can be interviewed by a programmer to provide the knowledge necessary to build a computer system. A machine learning system can study recorded data and subsequent machine failures and learn prediction rules. Second, there are problems where human experts exist, but where they are unable to explain their expertise. This is the case in many perceptual tasks, such as speech recognition, hand-writing recognition, and natural language understanding. Virtually all humans exhibit expert-level abilities on these tasks, but none of them can describe the detailed steps that they follow as they perform them. Fortunately, humans can provide machines with examples of the inputs and correct outputs for these tasks, so machine learning algorithms can learn to map the inputs to the outputs. Third, there are problems where phenomena are changing rapidly. In finance, for example, people would like to predict the future behavior of the stock market, of consumer purchases, or of exchange rates. These behaviors change frequently, so that even if a programmer could construct a good predictive computer program, it would need to be rewritten frequently. A learning program can relieve the programmer of this burden by constantly modifying and tuning a set of learned prediction rules. Fourth, there are applications that need to be customized for each computer user separately. Consider, for example, a program to filter unwanted electronic mail messages. Different users will need different filters. It is unreasonable to expect each user to program his or her own rules, and it is infeasible to provide every user with a software engineer to keep the rules up-to-date. A machine learning system can learn which mail messages the user rejects and maintain the filtering rules automatically. Machine learning addresses many of the same research questions as the fields of statistics, data mining, and psychology, but with differences of emphasis. Statistics focuses on understanding the phenomena that have generated the data, often with the goal of testing different hypotheses about those phenomena. Data mining seeks to find patterns in the data that are understandable by people. Psychological studies of human learning aspire to understand the mechanisms underlying the various learning behaviors exhibited by people (concept learning, skill acquisition, strategy change, etc.).

13,246 citations


Journal ArticleDOI
Gregor Kiczales1
TL;DR: This work proposes to use aspect-orientation to automate the calculation of statistics for database optimization and shows how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries.
Abstract: The performance of relational database applications often suffers. The reason is that query optimizers require accurate statistics about data in the database in order to provide optimal query execution plans. Unfortunately, the computation of these statistics must be initiated explicitly (e.g., within application code), and computing statistics takes some time. Moreover, it is not easy to decide when to update statistics of what tables in an application. A well-engineered solution requires adding source code usually in many places of an application. The issue of updating the statistics for database optimization is a crosscutting concern. Thus we propose to use aspect-orientation to automate the calculation. We show how nicely the update functionality can be modularized in an aspect and how easy it is to specify the exact places and the time when statistics updates should be performed to speed up complex queries. Due to the automatic nature, computation takes place on time for complex queries, only when necessary, and only for stale tables. The implementation language for the automated aspect-oriented statistics update concern is AspectJ, a well known and mature aspect-oriented programming language. The approach can however be implemented in any other aspect-oriented language. Unlike in traditional object-oriented pattern solutions, e.g. using the interceptor pattern, we do not have to modify existing code.

5,161 citations


Journal ArticleDOI
TL;DR: The state of the art in specification and verification, which includes advances in model checking and theorem proving, is assessed and future directions in fundamental concepts, new methods and tools, integration of methods, and education and technology transfer are outlined.
Abstract: Hardware and software systems will inevitably grow in scale and functionality. Because of this increase in complexity, the likelihood of subtle errors is much greater. Moreover, some of these errors may cause catastrophic loss of money, time, or even human life. A major goal of software engineering is to enable developers to construct systems that operate reliably despite this complexity. One way of achieving this goal is by using formal methods, which are mathematically based languages, techniques, and tools for specifying and verifying such systems. Use of formal methods does not a priori guarantee correctness. However, they can greatly increase our understanding of a system by revealing inconsistencies, ambiguities, and incompleteness that might otherwise go undetected. The first part of this report assesses the state of the art in specification and verification. For verification, we highlight advances in model checking and theorem proving. In the three sections on specification, model checking, and theorem proving, we explain what we mean by the general technique and briefly describe some successful case studies and well-known tools. The second part of this report outlines future directions in fundamental concepts, new methods and tools, integration of methods, and education and technology transfer. We close with summary remarks and pointers to resources for more information.

1,429 citations


Journal ArticleDOI
TL;DR: Cache memories are a general solution to improving the performance of a memory system by placing smaller faster memories in front of larger, slower, and cheaper memories to approach that of a perfect memory system—at a reasonable cost.
Abstract: A computer’s memory system is the repository for all the information the computer’s central processing unit (CPU, or processor) uses and produces. A perfect memory system is one that can supply immediately any datum that the CPU requests. This ideal memory is not practically implementable, however, as the three factors of memory capacity, speed, and cost are directly in opposition. By placing smaller faster memories in front of larger, slower, and cheaper memories, the performance of the memory system may approach that of a perfect memory system—at a reasonable cost. The memory hierarchies of modern general-purpose computers generally contain registers at the top, followed by one or more levels of cache memory, main memory (all three are semiconductor memory), and virtual memory (on a magnetic or optical disk). Figure 1 shows a memory hierarchy typical of today’s (1995) commodity systems. Performance of a memory system is measured in terms of latency and bandwidth. The latency of a memory request is how long it takes the memory system to produce the result of the request. The bandwidth of a memory system is the rate at which the memory system can accept requests and produce results. The memory hierarchy improves average latency by quickly returning results that are found in the higher levels of the hierarchy. The memory hierarchy usually reduces bandwidth requirements by intercepting a fraction of the memory requests at higher levels of the hierarchy. Some machines, such as high-performance vector machines, may have fewer levels in the hierarchy—increasing cost for better predictability and performance. Some of these machines contain no caches at all, relying on large arrays of main memory banks to supply very high bandwidth. Pipelined accesses of operands reduce the performance impact of long latencies in these machines. Cache memories are a general solution to improving the performance of a memory system. Although caches are smaller than typical main memory sizes, they ideally contain the most frequently accessed portions of main memory. By keeping the most heavily used data near the CPU, caches can service a large fraction of the requests without needing to access main memory (the fraction serviced is called the hit rate). Caches require locality of reference to work well transparently—they assume that accessed memory words will be accessed again quickly (temporal locality) and that memory words adjacent to an accessed word will be accessed soon after the access in question (spatial locality). When the CPU issues a request for a datum not in the cache (a cache miss), the cache loads that datum and some number of adjacent data (a cache block) into itself from main memory. To reduce cache misses, some caches are associative—a cache may place a given block in one of several places, collectively called a set. This set is content-addressable; a block may be accessed based on an address tag, one of which is coupled with each block. When a new block is brought into a set and the set is full, the cache’s replacement policy dictates which of the old blocks should be removed from the cache to make room for the new. Most caches use an approximation of least recently used

702 citations


Journal ArticleDOI
Paul Hudak1

516 citations


Journal ArticleDOI
TL;DR: The maturation of database management system (DBMS) technology has coincided with significant developments in distributed computing and parallel processing technologies as discussed by the authors, and the end result is the development of distributed database management systems and parallel DBMS that are now the dominant data management tools for highly data-intensive applications.
Abstract: The maturation of database management system (DBMS) technology has coincided with significant developments in distributed computing and parallel processing technologies. The end result is the development of distributed database management systems and parallel database management systems that are now the dominant data management tools for highly data-intensive applications. With the emergence of cloud computing, distributed and parallel database systems have started to converge. In this chapter, we present an overview of the distributed DBMS and parallel DBMS technologies, highlight the unique characteristics of each, and indicate the similarities between them. We also discuss the new challenges and emerging solutions.

438 citations


Journal ArticleDOI
TL;DR: This research has revolutionized the understanding of computation and has deep scientific and philosophical consequences which will be further recognized in the future.
Abstract: Theory of Computation (TOC) seeks to understand computational phenomena, be it natural, man-made or imaginative. TOC is an independent scientific discipline of fundamental importance. Its intrinsic goals (those which were achieved, those which are yet to be achieved, and those which are yet to be defined) transcend the immediate applicability to engineering and technology. Research in TOC has been extremely successful and productive in the few decades of its existence, with continuously growing momentum. This research has revolutionized the understanding of computation and has deep scientific and philosophical consequences which will be further recognized in the future. Moreover, this research and its dissemination through education and interaction was responsible for enormous technological progress. Much of the full version of our manuscript [2] is devoted to substantiating the strong statements made above. Here, due to space limitations, we merely list a few of the fundamental achievements of TOC.

379 citations


Journal ArticleDOI
TL;DR: Six types of metrics and models of software reuse and reusability are surveyed, and a classification structure is provided that will help users select them to improve productivity and quality.
Abstract: As organizations implement systematic software reuse programs to improve productivity and quality, they must be able to measure their progress and identify the most effective reuse strategies. This is done with reuse metrics and models. In this article we survey metrics and models of software reuse and reusability, and provide a classification structure that will help users select them. Six types of metrics and models are reviewed: cost-benefit models, maturity assessment models, amount of reuse metrics, failure modes models, reusability assessment models, and reuse library metrics.

362 citations


Journal ArticleDOI
TL;DR: A definition of contravariant, a type that varies in the inverse direction from one of its parts with respect to subtyping, and a tree of judgments obtained by applying the rules of a type system.
Abstract: type: A data type whose nature is kept hidden, in such a way that only a predetermined collection of operations can operate on it. Contravariant: A type that varies in the inverse direction from one of its parts with respect to subtyping. The main example is the contravariance of function types in their domain. For example, assume A<:B and vary X from A to B in X→C; we obtain A→C :> B→C. Thus X→C varies in the inverse direction of X. Covariant: A type that varies in the same direction as one of its parts with respect to subtyping. For example, assume A<:B and vary X from A to B in D→X; we obtain D→A <: D→B. Thus D→X varies in the same direction as X. Derivation: A tree of judgments obtained by applying the rules of a type system. Dynamic checking. A collection of run time tests aimed at detecting and preventing forbidden errors. Dynamically checked language: A language where good behavior is enforced during execution. Explicitly typed language: A typed language where types are part of the syntax. First-order type system: One that does not include quantification over type variables. Forbidden error: The occurrence of one of a predetermined class of execution errors; typically the improper application of an operation to a value, such as not(3). Good behavior: Same as being well behaved.

351 citations


Journal ArticleDOI
Antero Taivalsaari1
TL;DR: This article aims at a comprehensive understanding of inheritance, examining its usage, surveying its varieties, and presenting a simple taxonomy of mechanisms that can be seen as underlying different inheritance models.
Abstract: One of the most intriguing—and at the same time most problematic—notions in object-oriented programing is inheritance. Inheritance is commonly regarded as the feature that distinguishes object-oriented programming from other modern programming paradigms, but researchers rarely agree on its meaning and usage. Yet inheritance of often hailed as a solution to many problems hampering software development, and many of the alleged benefits of object-oriented programming, such as improved conceptual modeling and reusability, are largely credited to it. This article aims at a comprehensive understanding of inheritance, examining its usage, surveying its varieties, and presenting a simple taxonomy of mechanisms that can be seen as underlying different inheritance models.

311 citations


Journal ArticleDOI
TL;DR: This short paper emphasizes optimization of a single select-project-join query in a centralized relational DBMS.
Abstract: Given a query, there are many access plans that a database management system (DBMS) can follow to process it and produce its answer. All plans are equivalent in terms of their final output but vary in their cost, that is, the amount of time that they need to run. This cost difference can be several orders of magnitude large. Thus all DBMSs have a module that examines “all” alternatives and chooses the plan that needs the least amount of time. This module is called the query optimizer. Query optimization is a large area within the database field and has been surveyed extensively [Jarke and Koch 1984; Mannino et al. 1988]. This short paper emphasizes optimization of a single select-project-join query in a centralized relational DBMS. An abstraction of the query optimization process, divided into a rewriting and a planning stage, is shown in Figure 1. The functionality of each module in Figure 1 is described in the following.

Journal ArticleDOI
TL;DR: A decision tree is a formalism for expressing a mapping from attribute values to classes and is either a leaf node labeled with a class or a structure consisting of a test node linked to two or more subtrees.
Abstract: Inductive inference is the process of moving from concrete examples to general models. In one form, the goal is to learn how to classify objects or situations by analyzing a set of instances whose classes are known. Classes here are mutually exclusive labels such as medical diagnoses, qualitative economic projections, image categories, or failure modes. Instances are typically represented as attribute-value vectors that give the numerical or nominal values of a fixed collection of properties. Learning input consists of a set of such vectors, each belonging to a known class, and the output consists of a mapping from attribute values to classes. This mapping should accurately classify both the given instances and other unseen instances. A decision tree is a formalism for expressing such mappings. A tree is either a leaf node labeled with a class or a structure consisting of a test node linked to two or more subtrees. A test node computes some outcome based on the attribute values of an instance, where each possible outcome is associated with one of the subtrees. An instance is classified by starting at the root node of the tree. If this node is a test, the outcome for the instance is determined and the process continues using the appropriate subtree. When a leaf is eventually encountered, its label gives the predicted class of the instance. A decision tree can be constructed from a set of instances by a divide-andconquer strategy. If all the instances belong to the same class, the tree is a leaf with that class as label. Otherwise, a test is chosen that has different outcomes for at least two of the instances, which are partitioned according to this outcome. The tree has as its root a node specifying the test and, for each outcome in turn, the corresponding subtree is obtained by applying the same procedure to the subset of instances with that outcome. From a geometric perspective, a set of x attributes defines an x-dimensional description space in which each instance is a point. Partitioning a set of instances according to test outcome corresponds to inserting decision surfaces in this space. In many systems, each test is constrained to reference the value of a single attribute A, so that a test outcome might be A 5 c for some value c of a nominal attribute, or A , t in which a numeric attribute is compared to a threshold t. Surfaces produced by single-attribute tests are hyperplanes orthogonal to the tested attribute A; any decision tree using only such tests will partition the description space into hyperrectangles, each associated with a class. More complex tests can be used to reduce the number of times that the instances are subdivided, thus avoiding the data fragmentation problem. For multivalued nominal attributes, the simplest generalization is to subset tests A [ {c1, c2, . . . }. Other sophisticated tests use more than one attribute, for example, logical combinations, sets of conditions, or linear combinations of numeric attributes (this latter permitting decision surfaces that are arbitrary hyperplanes). Unless there are identical attributevalue vectors labeled with different classes, any choice of tests leads to a tree that is consistent with the in-

Journal ArticleDOI
TL;DR: Partial evaluation provides a unifying paradigm for a broad spectrum of work in program optimization compiling interpretation and the generation of automatic program generators and has important applications to scientific computing, logic programming, metaprogramming, and expert systems.
Abstract: Partial evaluation provides a unifying paradigm for a broad spectrum of work in program optimization compiling interpretation and the generation of automatic program generators [Bjorner et al. 1987; Ershov 1992; and Jones et al. 1993]. It is a program optimization technique, perhaps better called program specialization, closely related to but different from Jorring and Scherlis' staging transformations [1986]. It emphasizes, in comparison with Burstall and Darlington [1977] and Jorring and Scherlis [1986] and other program transformation work, full automation and the generation of program generators as well as transforming single programs. Much partial evaluation work to date has concerned automatic compiler generation from an interpretive definition of programming language, but it also has important applications to scientific computing, logic programming, metaprogramming, and expert systems; some pointers are given later.

Journal ArticleDOI
TL;DR: The three challenges of object-oriented design are to identify the objects and classes needed to implement the software, describe the relationships between the identifiedObjects and classes, and define the behavior of the objects by describing the function implementations of each class.
Abstract: The three challenges of object-oriented design are to identify the objects and classes needed to implement the software, describe the relationships between the identified objects and classes, and define the behavior of the objects by describing the function implementations of each class. To discover an initial set of objects and classes, researchers look at the noun phrases and nouns used to analyze the system and to describe the system requirements. Possible sources of objects include tangible things (cars, telemetry data, pressure sensors); roles (mother, teacher, politician); events (landing, interrupt, request); interactions (loan, meeting, intersection); people; places; organizations; devices; and locations [Booch 1991]. Walking through scenarios of system usage, focusing on the discovery of the important objects and their responsibilities, is an important technique used early in the design process [Jacobson et al. 1992; Wirfs-Brock et al. 1990]. When the important objects have been found, the details of the class relationships and object behavior are developed through a set of interconnected models that capture four dimensions of the software architecture: logical static, logical dynamic, physical static, and physical dynamic [Booch 1991]. The logical static model describes the relationships of instantiation (class membership), association, aggregation (part-of), and generalization (is-a). This is called the system object model [Coleman 1994]. The generalization relationship implies inheritance of attributes and methods. Graphical notations derived from the entity relationship notation for data modeling are frequently used to define the object model [Rumbaugh et al. 1991]. Constraints such as cardinality (for example, one-one, one-many, many-many) that are important to the design are also expressed in the object model. A textual notation derived from BackusNaur-form grammars is also used [Lieberherr 1996]. Grammars provide a more concise representation of the class structures. The logical dynamic model describes the interactions between objects. The interactions define the run-time behavior of the system in terms of a set of participating objects, an ordered sequence of messages between the objects, and a determination of the visibility of each object in the interaction. Object interaction diagrams [Booch 1991] and interaction graphs [Coleman 1994] are used to describe important interactions. These show the participating objects and the time-ordered messages between the objects. Object visibility within an interaction is expressed via visibility graphs. Object visibility determines how an object becomes part of the scope of the method sending it a message. For example, it may be a method argument, a local variable, a new object, or a part of the current object executing the

Journal ArticleDOI
TL;DR: In this paper, the authors propose an interpretative interpretation of the word "interpretation" and "interpretation" in the context of this paper...,..
Abstract: Interpretation

Journal ArticleDOI
TL;DR: Imperative functional programming is the application of the ideas of functional programming to imperative computations, and merely applies it to a new context, that of imperative compu-
Abstract: Our intuitive idea of a function is that it describes the dependence of one quantity upon another. There is no condition on what kind of quantities are involved. They could be integers, Turing machines, binary search trees, window hierarchies, digital circuits or whatever. The possibilities are endless. The idea of functional programming is that functions are described applicatively, by plugging together other functions. This recursive dependence of functions on other functions bottoms out with the primitive operators. If the primitive operators are “effective,” i.e., they can be used to calculate, compute, construct or build one quantity from another, then all functions expressed applicatively are similarly effective. Imperative functional programming is the application of these ideas to imperative computations. Quantities here are imperative computations and functions denote dependences between imperative computations. Effectiveness of a function means that a computation produced from it can be effectively carried out whenever the input computations can be effectively carried out. It is often felt that imperative computations and functional programming are in conflict. Adding imperative computations to a functional programming language is found to destroy its “referential transparency.” See, for example, [Abelson et al., 1985, Sec. 3.1] for a discussion of the issue. However, in languages where such issues arise, imperative computations are thrown together by extending or modifying functional computation. The idea that functions denote dependences is lost in the process. In contrast, imperative functional programming does not involve altering functional computation in any way. It merely applies it to a new context, that of imperative compu-


Journal ArticleDOI
TL;DR: A coordination model provides a framework in which the interaction of active and independent entities called agents can be expressed and should cover the issues of creation and destruction of agents, communication among agents, and spatial distribution of agents as well as synchronization and distribution of their actions over time.
Abstract: Early concurrent languages supported interactions through shared variables. Languages based on message passing were also a very early idea that gained popularity as soon as software engineers started to design and build software for distributed computer systems. A more recent approach consists of using higher-level programming models and languages for distributed programming, called coordination models and languages. “A coordination model is the glue that binds separate activities into an ensemble” [Carriero and Gelernter 1992]. In other words, a coordination model provides a framework in which the interaction of active and independent entities called agents can be expressed. A coordination model should cover the issues of creation and destruction of agents, communication among agents, and spatial distribution of agents, as well as synchronization and distribution of their actions over time. A constructive approach to define coordination models consists of identifying the components out of which they are built:

Journal ArticleDOI
TL;DR: This report describes the historical and intellectual foundations of HCI and then summarizes selected strategic directions in human-computer interaction research, which involves input and output devices and the interaction techniques that use them.
Abstract: Human-computer interaction (HCI) is the study of how people design, implement, and use interactive computer systems and how computers affect individuals, organizations, and society. This encompasses not only ease of use but also new interaction techniques for supporting user tasks, providing better access to information, and creating more powerful forms of communication. It involves input and output devices and the interaction techniques that use them; how information is presented and requested; how the computer’s actions are controlled and monitored; all forms of help, documentation, and training; the tools used to design, build, test, and evaluate user interfaces; and the processes that developers follow when creating interfaces. This report describes the historical and intellectual foundations of HCI and then summarizes selected strategic directions in human-computer interaction research. Previous important reports on HCI directions include the results of the 1991 [Sibert and Marchionini 1993] and 1994 [Strong 1994] NSF studies on HCI in general, and the 1994 NSF study on the World-Wide Web [Foley and Pitkow 1994].

Journal ArticleDOI
TL;DR: The audit process gathers data about activity in the system and analyzes it to discover security violations or diagnose their cause and is usually called intrusion detection.
Abstract: —Authentication establishes the identity of one party to another. Most commonly authentication establishes the identity of a user to some part of the system, typically by means of a password. More generally, authentication can be computer-to-computer or process-toprocess and mutual in both directions. —Access control determines what one party will allow another to do with respect to resources and objects mediated by the former. Access control usually requires authentication as a prerequisite. —The audit process gathers data about activity in the system and analyzes it to discover security violations or diagnose their cause. Analysis can occur offline after the fact or online in real time. In the latter case, the process is usually called intrusion detection.

Journal ArticleDOI
TL;DR: An overview of the program transformation methodology, focusing on the so-called “rules + strategies” approach in the case of functional and logic programs, is presented.
Abstract: We present an overview of the program transformation methodology, focusing our attention on the so-called “rules + strategies” approach in the case of functional and logic programs. The paper is intended to offer an introduction to the subject. The various techniques we present are illustrated via simple examples.

Journal ArticleDOI
TL;DR: A genetic algorithm is a computational model of biological evolution that describes how binary strings are stored in a computer’s memory and over time are modified in much the same way that populations of individuals evolve under natural selection.
Abstract: A genetic algorithm is a computational model of biological evolution. Genetic algorithms are useful both as search methods for solving problems and for modeling evolutionary systems. In genetic algorithms, binary strings are stored in a computer’s memory and over time are modified in much the same way that populations of individuals evolve under natural selection. Although the computational setting is highly simplified when compared with the natural world, genetic algorithms are capable of evolving surprisingly complex and interesting structures. These structures, called individuals, can represent solutions to problems, strategies for playing games, visual images, or computer programs. Genetic algorithms are loosely based on ideas from population genetics. First, a population of individuals is created randomly. In the simplest case, each individual is a bit string and can be thought of as a candidate solution for some problem of interest, as shown in Figure 1. Variations among individuals in the population result in some individuals being more fit than others (e.g., better problem solutions). These differences are used to bias the selection of a new set of candidate solutions at the next time step, referred to as selection. During selection, a new population is created by making copies of more successful individuals and deleting less successful ones. However, the copies are not exact. There is a probability of mutation (random bit flips), crossover (exchange of corresponding substrings between two individuals), or other changes to the bit string during the copy operation. By transforming the previous set of good individuals to a new one, the mutation and crossover operations generate a new set of individuals, or samples, that ideally have a better than average chance of also being good. When this cycle of evaluation, selection, and genetic operations is iterated for many generations, the overall fitness of the population generally improves, and the individuals in the population represent improved “solutions” to whatever problem was posed in the fitness function. Figure 1 shows an example of a genetic algorithm being used to optimize a simple function. There are many ways of implementing this idea, the most prevalent being the strategy introduced by Holland [Holland 1975; Goldberg 1989; Forrest 1993] and illustrated in Figure 1. In the figure a population of four individuals is shown. Each is assigned a fitness value by the function F(x, y) 5 yx 2 x. The fitness values for the population at TN are shown for each individual (underneath the arrow labeled “Differential Reproduction”). The first five bits are a gray-coded representation of x and the second five bits are a gray-coded representation of y (normalized over the interval [0, 1). On the basis of these fitnesses, the selection phase assigns the first individual (0000001101) one copy, the second (0101010010) two, the third (1111111000) one copy, and the fourth

Journal ArticleDOI
J. S. Shang1
TL;DR: Numerical simulation technology is the most cost-effective means of meeting many technical challenges in the areas of electromagnetic signature processing, antenna design, biomedical application, electromagnetic coupling, microwave device design and assembly, as well as microcircuit packaging.
Abstract: Computational electromagnetics (CEM) is a natural extension of the analytical approach to solving the Maxwell equations [Elliott 1966]. This scientific discipline is based on numerically solving the governing partial differential or integral equations derived from first principles. In spite of a fundamental difference in representing the solution either in the continuum or in the discretized space, both approaches satisfy all pertaining theorems rigorously. Although numerical solutions of CEM generate only a point value for a specific simulation, the complexity of physics and of the field configuration are no longer the limiting factors as they are to the analytical approach. With the advent of high-performance computing systems, CEM is becoming the mainstay for engineering applications. Numerical simulation technology is the most cost-effective means of meeting many technical challenges in the areas of electromagnetic signature processing, antenna design, biomedical application, electromagnetic coupling, microwave device design and assembly. In fact, the military applications in radar signature reduction and integrated broadband communication system design have become the cutting edge of this relatively new technology. The technical transitions have already favorably influenced commercial ventures in telecommunications, magnetically levitated transportation systems, microwave data link optimization, and mobile antenna design, as well as microcircuit packaging. All computational electromagnetics methods also have limitations in their ability to duplicate physics in high fidelity. For a specific application, the numerical accuracy requirement has a direct connection to the computational efficiency. The inaccuracy incurred by a numerical simulation is attributable to the mathematical model of the physics, the numerical algorithm, and the computational accuracy. For example, in the electromagnetic signature simulations, the scattering-field formulation eliminates completely the quasiphysical error involved in the incident wave when it propagates from the far field boundary to the scatter. This accuracy advantage over the total-field formulation is significant by invoking the equivalent field theorem to accomplish the nearto far-field transformation. The computational accuracy is controlled by the algorithm and computing system adopted. Error induced by the discretization consists of the roundoff and the truncation error. The roundoff error is contributed by the computing system and is problem-size-dependent. Because this error behavior is random, it is the most difficult to evaluate. One anticipates that this type of error will be a concern for solving procedures involving large-scale matrix manipulation such as the method of moments [Harrington 1968] and the implicit numerical algorithm for finite-difference or finite-volume methods. The truncation error for time-dependent calculations appears as dissipation and dispersion, which can be assessed and alleviated by mesh system refinements. Finally, the numerical error can be the consequence of a specific numerical formulation. The error becomes pronounced when a special phenomenon is investigated or when a discontinuous and distinctive

Journal ArticleDOI
TL;DR: Constraints arise naturally in most areas of human endeavor and are the natural medium of expression for formalizing regularities that underlie the computational and (natural or designed) physical worlds and their mathematical abstractions.
Abstract: A constraint can be thought of intuitively as a restriction on a space of possibilities. Mathematical constraints are precisely specifiable relations among several unknowns (or variables), each taking a value in a given domain. Constraints restrict the possible values that variables can take, representing some (partial) information about the variables of interest. For instance, “The second side of a sheet of a paper must be imaged 9000 milliseconds after the time at which the first side is imaged,” relates two variables without precisely specifying the values they must take. One can think of such a constraint as standing for (a possibly infinite) set of values, in this case the set {^0, 9000&, ^1500, 10500&, . . .}. Constraints arise naturally in most areas of human endeavor. They are the natural medium of expression for formalizing regularities that underlie the computational and (natural or designed) physical worlds and their mathematical abstractions, with a rich tradition going back to the days of Euclidean geometry, if not earlier. For instance, the three angles of a triangle sum to 180 degrees; the four bases that make up DNA strands can only combine in particular orders; the sum of the currents flowing into a node must equal zero; the trusses supporting a bridge can only carry a certain static and dynamic load; the pressure, volume, and temperature of an enclosed gas must obey the “gas law”; Mary, John, and Susan must have different offices; the relative position of the scroller in the window scroll-bar must reflect the position of the current text in the underlying document; the derivative of a function is positive at zero; the function is monotone in its first argument, and so on. Indeed, whole subfields of mathematics (e.g., theory of Diophantine equations, group theory) and many celebrated conjectures of mathematics (e.g., Fermat’s Last Theorem) deal with whether certain constraints are satisfiable. Constraints naturally enjoy several interesting properties. First, as previously remarked, constraints may specify partial information—a constraint need not uniquely specify the value of its variables. Second, they are additive: given a constraint c1, say, X 1 Y $ Z, another constraint c2 can be added, say, X 1 Y # Z. The order of imposition of constraints does not matter; all that matters at the end is that the conjunction of constraints is in effect. Third,

Journal ArticleDOI
TL;DR: To meet the software quality challenge, research must first meet some substantial challenges and improve the current tools, technologies, and their cost-benefit characterizations, but researchers must also take the lead in looking beyond post-development testing to study the tools and technologies for building inherent quality into software.
Abstract: The challenge of research in software quality is to provide tools and technology that will enable the software industry to deploy software products and services that are safe, dependable, and usable within an economic framework allowing companies to compete effectively. Meeting this challenge will have a significant effect on national economies, national security, international competitiveness, and societal well-being. Software quality concerns are quite broad, including, for example, correctness, robustness, readability, and evolvability. There is no single monolithic measure of software quality, and no general agreement about how to quantify definitively any of the key quality concerns. The actual levels of quality achieved in practice are dictated by quality assessment tools and technologies and willingness to pay for applying them. To meet the software quality challenge, research must first meet some substantial challenges. It is necessary to improve the current tools, technologies, and their cost-benefit characterizations. But researchers must also take the lead in looking beyond post-development testing to study the tools and technologies for building inherent quality into software. New analysis and design technologies will have to play a greater role in achieving and demonstrating the quality of software, increasingly reducing dependence upon after-the-fact testing techniques. While awaiting the results of this needed innovative research, practitioners could benefit significantly from the transfer of past and current research to practice. One major obstacle to transition seems to be a scarcity of experimental work that is sufficiently solid and well measured to justify the risks entailed in a transition to industrial practice. Past technology transfer failures are damaging to both the research and practitioner communities.

Journal ArticleDOI
Thomas Dean1
TL;DR: The STRIPS formulation provides the semantic foundations for many extensions, including those handling external events, multiple agents, probabilistic transformations, and variants that allow the agent to observe aspects of the current state and choose actions conditioned on observations.
Abstract: Interest in automated planning is at least as old as artificial intelligence. Ernst et al. [1969] describe a solution to a problem in terms of a sequence of steps that transforms some initial description of the problem state, for example, the initial configuration of a puzzle, into a description satisfying a specified goal criterion. The steps (transformations) are called operators and a problem is defined in terms of a set of operators and a language for describing problem states. In automated planning, the problem states correspond to instantaneous descriptions of the world and operators correspond to actions that an agent can perform to change the state of the world. The STRIPS formulation for planning problems [Fikes and Nilsson 1971] employs propositional logic as a language for describing states of the world, a simple but general format for specifying operators, and a clear semantics for change over time. In the STRIPS formulation, there is a set of conditions, for example, a set of Boolean variables, used to describe states. A complete assignment maps the set of conditions to possible values, for example, truth values, and a partial assignment maps a subset of conditions to values. A state is a complete assignment. An operator consists of two partial assignments; the first, called the preconditions, determines the states in which the operator can be applied, and the second, called the postconditions, determines the state that results from applying the operator in a particular starting state. Implicit frame axioms specify that the value of any condition not mentioned in an operator’s postconditions is unchanged by the application of the operator. A planning problem (instance) is specified by a set of operators, an initial state, and a goal, for example, a Boolean formula. Generally speaking, a solution is a partially ordered multiset of operators such that any total ordering consistent with the given partial order transforms the assignment specified by the initial state into a assignment that satisfies the goal formula. The STRIPS formulation provides the semantic foundations for many extensions, including those handling external events, multiple agents, probabilistic transformations, and variants that allow the agent to observe aspects of the current state and choose actions conditioned on observations.

Journal ArticleDOI
TL;DR: Future database systems can be expected to offer the high level of abstraction of object-orientation along with the relative efficiency and uniformity of the relational model.
Abstract: ion of the design concepts used in the implementation of databases. As a result, the model is tied more closely to physical-level design than is the relational model. In the network model, data items are represented by collections of records and relationships among data are represented by links, which correspond to pointers at the physical level. The hierarchical model is similar to the network model except that links in the hierarchical model must form a tree structure, whereas the network model allows arbitrary graphs. OBJECT-RELATIONAL DATA MODELS Object-relational data models are hybrids of the object-oriented and the relational data models. They extend the relational data model by providing an extended type system and object-oriented concepts such as object identity. The extended type systems allow complex types including nonatomic values such as nested relations and inheritance at the level of attribute domains as well as at the level of relations. Such extensions attempt to preserve the relational foundations while extending the modeling power. There is a trend towards the amalgamation of features of the relational and object-oriented models. The SQL-3 standard currently under development includes object-oriented features within the framework of an extended version of the current relational SQL standard. Market-leading relational database products are adding object-oriented features so as to compete with object-oriented and object-relational database products. Future database systems can be expected to offer the high level of abstraction of object-orientation along with the relative efficiency and uniformity of the relational model. Data Models • 107 ACM Computing Surveys, Vol. 28, No. 1, March 1996

Journal ArticleDOI
TL;DR: Incremental models [Mills et al. 1980] are a development of the waterfall model that attempt to provide some development stability while allowing users some opportunity for specification change.
Abstract: (1) Specification. The functionality of the software and its operating constraints are specified in detail. (2) Design and implementation. The overall structure of the software is designed and specific software components identified. These are implemented using some programming language, often by separate individuals or teams. (3) Integration and testing. Individually developed modules are integrated into a complete system and tested. (4) Operation and maintenance. The software is delivered to the customer and modified to meet changing requirements and to repair errors discovered in use. The problem with this model is the lack of feedback from one stage to another. Specification, design, and implementation problems are often discovered only after implementation when the system has been integrated. Once a specification has been frozen, it is difficult to change in response to changing user needs. However, stakeholders in the system (end-users, managers, and so on) find it difficult to anticipate their real needs for software support, and both organizational and end-user requirements change during the development process. There is therefore a constant pressure for specification change. This means that, in practice, there is always some iteration between the phases of the model, but this is invariably fairly limited and the delivered software may not meet the real needs of the customer. This led to widespread criticism of the waterfall model [Gladden 1982; McCracken and Jackson 1982] and the development of alternative software processes. Incremental models [Mills et al. 1980] are a development of the waterfall model that attempt to provide some development stability while allowing users some opportunity for specification change. In this approach, the system functionality is partitioned into a series of increments and these are developed and delivered one by one. While one increment is being developed, its specification is frozen, but the specification of other increments may change. A version of the system is delivered early to users and they may experiment with it to help clarify their needs for later system increments.

Journal ArticleDOI
TL;DR: A model based on the different streams used in the computation process, this work represents some of the different kinds of parallelism available through four combinations that describe most familiar parallel architectures.
Abstract: Parallel or concurrent operation has many different forms within a computer system. Using a model based on the different streams used in the computation process, we represent some of the different kinds of parallelism available. A stream is a sequence of objects such as data, or of actions such as instructions. Each stream is independent of all other streams, and each element of a stream can consist of one or more objects or actions. We thus have four combinations that describe most familiar parallel architectures:

Journal ArticleDOI
TL;DR: Key future challenges and research related to strategic directions are highlighted and a vision of the field for the next ten years is presented in Section 5, which summarizes the paper.
Abstract: Real-time computing is an enabling technology for many important application areas, including process control, nuclear power plants, agile manufacturing, intelligent vehicle highway systems, avionics, air-traffic control, telecommunications (the information superhighway), multimedia, real-time simulation, virtual reality, medical applications (e.g., telemedicine and intensive-care monitoring), and defense applications (e.g., command, control and communications). In particular, almost all safety-critical systems and many embedded computer systems are real-time systems. Further, realtime technology is becoming increasingly important and pervasive, e.g., more and more infrastructure of the world depends on it. Strategic directions for research in real-time computing involve addressing new types of real-time systems including open real-time systems, globally distributed real-time, and multimedia systems. For each of these, research is required in the areas of system evolution, composibility, software engineering, the science of performance guarantees, reliability and formal verification, general system issues, programming languages, and education. Economic and safety considerations, as well as the special problems that timing constraints cause, must be taken into account in the solutions. In Section 2, several examples of realtime systems, their corresponding importance, and several examples of research success are presented. In Section 3 key future challenges and research related to strategic directions are highlighted. A vision of the field for the next ten years is presented in Section 4. Section 5 summarizes the paper.