Formal language

About: Formal language is a research topic. Over the lifetime, 5763 publications have been published within this topic receiving 154114 citations.

Query languages for the casual user: Exploring the middle ground between formal and natural languages

Abstract: In the past the non-programmer who wanted the information contained in a computer database had to employ an expert programmer knowledgeable in the language and structure of the database. Now languages are being developed that are designed to be used by an infrequent or “casual” user who has limited knowledge of how the data is stored or retrieved by the computer. These special purpose query languages which allow these casual users to retrieve information from computer databases are commonly referred to as “nonprocedural” (Leavenworth and Sammet, 1974) because users need only describe the data to be retrieved, not how it is to be retrieved. These languages can be classified into two basic types which are characterized by the level of constraint imposed on the syntax and vocabulary of the language (Ehrenreich, 1981). Formal query languages have a very constrained syntax and vocabulary, while natural query languages have a relatively unconstrained syntax and vocabulary.If we consider the level of constraint that can be imposed on a query language as a continuum, then formal and natural query languages represent the two ends of this continuum. There has been considerable debate over the issue of which end of this continuum best meets the needs of the casual database user (e.g. Hill, 1972; Petrick, 1976; Shneiderman, 1980). Proponents of formal languages contend that these users benefit from learning a constrained language which teaches a concise and unambiguous way of communicating with the computer. Proponents of natural languages, on the other hand, contend that more people would be able to access database information if they could use their own natural languages. Evidence from studies of the use of some of these query languages however, indicate that neither formal, nor natural languages are easy to use. These studies suggest that the casual user will have difficulty operating at either end of the level-of-constraint continuum.

Legal Procedures as Formal Conversations: Contracting on a Performative Network

Abstract: Electronic Data Interchange (EDI) is a telecommunications system that many view as the next major productivity gain made possible by information technology. This paper discusses how our semantic, procedure-oriented view of business transactions leads to a different kind of telecommunications system -- a performative network. Viewing procedures as formal conversations, we present a representation schema and grammar to model these conversations and initiate the development of a formal language by which users can cooperate, negotiate, and make commitments over a performative network. Our approach complements and extends EDI's syntactic, record-format orientation, seeking to express not only the data transmitted through these transactions but also the semantics of the procedures themselves.

Formal models for user interface design artefacts

Abstract: There are many different ways of building software applications and of tackling the problems of understanding the system to be built, designing that system and finally implementing the design. One approach is to use formal methods, which we can generalise as meaning we follow a process which uses some formal language to specify the behaviour of the intended system, techniques such as theorem proving or model-checking to ensure the specification is valid (i.e., meets the requirements and has been shown, perhaps by proof or other means of inspection, to have the properties the client requires of it) and a refinement process to transform the specification into an implementation. Conversely, the approach we take may be less structured and rely on informal techniques. The design stage may involve jotting down ideas on paper, brainstorming with users etc. We may use prototyping to transform these ideas into working software and get users to test the implementation to find problems. Formal methods have been shown to be beneficial in describing the functionality of systems, what we may call application logic, and underlying system behaviour. Informal techniques, however, have also been shown to be useful in the design of the user interface to systems. Given that both styles of development are beneficial to different parts of the system we would like to be able to use both approaches in one integrated software development process. Their differences, however, make this a challenging objective. In this paper we describe models and techniques which allow us to incorporate informal design artefacts into a formal software development process.

Context-sensitive immediate constituent analysis—context-free languages revisited

Abstract: The ability of context-sensitive grammars to generate non-context-free languages is well-known. However, phrase structure rules are often used in both natural and artificial languages, not to generate sentences, but rather to analyze or parse given putative sentences. Linguistic arguments have been advanced that this is the more fruitful use of context-sensitive rules for natural languages, and that, further, it is the purported phrase-structure tree which is presented and analyzed, rather than merely the terminal string itself. In this paper, a language is shown to be context-free if and only if there is a finite set of context-sensitive rules which parse this language; i.e., if and only if there is a collection of trees whose terminal strings are this language and a finite set of context-sensitive rules which analyze exactly these trees.

Learning local languages and their application to DNA sequence analysis

Abstract: This paper presents an efficient algorithm for learning in the limit a special type of regular languages, called strictly locally testable languages from positive data, and its application to identifying the protein /spl alpha/-chain region in amino acid sequences. First, we present a linear time algorithm that, given a strictly locally testable language, learns its deterministic finite state automaton in the limit from only positive data. This provides one with a practical and efficient method for learning a specific concept domain of sequence analysis. We then describe several experimental results using the learning algorithm developed above. Following a theoretical observation which strongly suggests that a certain type of amino acid sequences can be expressed by a locally testable language, we apply the learning algorithm to identifying the protein /spl alpha/-chain region in amino acid sequences for hemoglobin. Experimental scores show an overall success rate of 95% correct identification for positive data, and 96% for negative data.