29923826
A Relational Dataflow Database Machine Based on Hierarchical Ring Network
3145493
KPSP: A Knowledge Programming System based on Prolog
29212181
Concurrency and inheritance in actor-based object-oriented languages
Abstract The combination of concurrent and object-oriented programming is a promising paradigm. However, the design of such an integrated language faces a serious problem: concurrent features of the language may interfere with object-oriented features such as inheritance and encapsulation. We present a new concurrency control mechanism for concurrent object-oriented languages based on the actor model, with the aim of avoiding such a problem. The concurrency constraints of an object are expressed with a pair of constructs—behavior abstraction sets and replacement clauses. They are completely separated from the code of methods; moreover, they are the units of inheritance. We introduce a new replacement scheme called lazy replacement for actor-based languages to reduce complexity in expressing the concurrency constraints of objects. We examine the relationship between the proposed concurrency control mechanism and a well-known inheritance mechanism using an experimental language.
26782414
The Semantics of a Functional Logic Language with Input Mode
1326236
History Sensitive String for Multiple Alphabets
In most cases, to represent characters in a computer, conventional code systems such as ASCII, EBCDIC, or BCD, whose code-length is uniform, have been used. In some countries, where the native language is not English, people can easily adapt their alphabet to these code systems by simply replacing the Enghsh alphabet with the alphabet of their native language. In other countries, especially in Korea and Japan, a straightforward application of the conventional code system is not possible. This is because, to compose a sentence, people customarily intermix words each of which may be constructed by different alphabets. For example, in Korea, they have an alphabet for their native language called Hangul. Hangul is a complete language by which Koreans can communicate with each other. However, Korean culture was influenced by China and more recently by the western countries. This results in widespread usage of four different types of documents in Korea. Documents may be written in Hangul only, Hangul with Chinese words, Hangul with English words, and Hangul with both Chinese and English words. Even in these cases, Hangul is the main alphabet. Another example of the applications of multiple alphabets in a single text are the high level language programs in Korean environment where the program language is a popular high level language such as PASCAL, C, or LISP, but variable names or data in the program may consist of Korean characters [7,9]. In this case, the main alphabet is English. Another example using heterogeneous characters is the use of attributes such as color, size, or font in high quality text editors. In such cases, characters from multiple alphabets should be used in a computer. Since each alphabet may have characteristics different from each other, some coding methods for multiple alphabets can be considered. When the sizes of the alphabets are significantly different from each other, employment of codes of a uniform length is prohibitively expensive. There are two different techniques to encode the multiple alphabets into a single code system. In the following sections, two coding methods of multiple alphabets are generalized, and their advantages and disadvantages are analyzed.
39501622
A logic programming approach to hybrid knowledge representation
A new hybrid system called Sphinx is presented which combines classification-based reasoning with logic programming technique. It consists of two major components: a terminological component and an assertional one. The former uses a frame-based knowledge representation scheme based on classification and the latter is a theorem prover based on Horn logic. The assertional component can also handle a first-order query language and wh-questions. A new knowledge base maintenance mechanism based on the negation as failure inference rule enables Sphinx to support incremental assertions and retractions. In addition, Sphinx provides explanation capability to help the user in developing and debugging knowledge bases.
18975029
An asymptotic analysis of band-limited DS/SSMA communication systems
A new asymptotic analysis is presented to establish whether or not commonly used techniques to approximate the performance of direct-sequence spread-spectrum multiple-access (DS/SSMA) systems still apply when the systems are strictly band limited. The results apply to any linear data modulation and spreading scheme. The interference components, including the interchip interference (ICI) of a linear receiver output, are shown to be asymptotically jointly Gaussian random variables conditioned on the phases and delays of the interfering signals. Expressions for the error probabilities of band-limited systems are also developed from this result.
398600
What's new on the web?: the evolution of the web from a search engine perspective
We seek to gain improved insight into how Web search engines shouldcope with the evolving Web, in an attempt to provide users with themost up-to-date results possible. For this purpose we collectedweekly snapshots of some 150 Web sites over the course of one year,and measured the evolution of content and link structure. Our measurements focus on aspects of potential interest to search engine designers: the evolution of link structure over time, the rate ofcreation of new pages and new distinct content on the Web, and the rate of change of the content of existing pages under search-centric measures of degree of change.Our findings indicate a rapid turnover rate of Web pages, i.e.,high rates of birth and death, coupled with an even higher rate ofturnover in the hyperlinks that connect them. For pages that persistover time we found that, perhaps surprisingly, the degree of contentshift as measured using TF.IDF cosine distance does not appear to beconsistently correlated with the frequency of contentupdating. Despite this apparent non-correlation, the rate of content shift of a given page is likely to remain consistent over time. That is, pages that change a great deal in one week will likely change by a similarly large degree in the following week. Conversely, pages that experience little change will continue to experience little change. We conclude the paper with a discussion of the potential implications ofour results for the design of effective Web search engines.
10966719
The Evolution of the Web and Implications for an Incremental Crawler
In this paper we study how to build an effective incremental crawler. The crawler selectively and incrementally updates its index and/or local collection of web pages, instead of periodically refreshing the collection in batch mode. The incremental crawler can improve the ``freshness'' of the collection significantly and bring in new pages in a more timely manner. We first present results from an experiment conducted on more than half million web pages over 4 months, to estimate how web pages evolve over time. Based on these experimental results, we compare various design choices for an incremental crawler and discuss their trade-offs. We propose an architecture for the incremental crawler, which combines the best design choices.
171503
Parallel crawlers
In this paper we study how we can design an effective parallel crawler. As the size of the Web grows, it becomes imperative to parallelize a crawling process, in order to finish downloading pages in a reasonable amount of time. We first propose multiple architectures for a parallel crawler and identify fundamental issues related to parallel crawling. Based on this understanding, we then propose metrics to evaluate a parallel crawler, and compare the proposed architectures using 40 million pages collected from the Web. Our results clarify the relative merits of each architecture and provide a good guideline on when to adopt which architecture.
513620
Synchronizing a database to improve freshness
In this paper we study how to refresh a local copy of an autonomous data source to maintain the copy up-to-date. As the size of the data grows, it becomes more difficult to maintain the copy \ fresh, “making it crucial to synchronize the copy effectively. We define two freshness metrics, change models of the underlying data, and synchronization policies. We analytically study how effective the various policies are. We also experimentally verify our analysis, based on data collected from 270 web sites for more than 4 months, and we show that our new policy improves the \ freshness” very significantly compared to current policies in use.