Although some success has been achieved in the design of front-end natural language processors to data base management systems, transporting the processor to various data base management systems has proven to be elusive. A transportable system must be modular; it must be able to adapt to radically different data domains; and it must be able to communicate with many different data managers. The system developed accomplishes this by maintaining its own knowledge base distinct from the target data base management system, so that no communication is needed between the natural language processor and the data manager during the parse. The knowledge base is developed by interviewing the system administrator about the structure and meaning of the elements in the target data base. The natural language processor then converts the natural language query into an unambiguous intermediate-language query, which is easily converted to P the target query language using simple syntactic methods. / Master of Science

The main purpose of this study was to review and modify some of the work that has been done concerning the generation of pseudo-random numbers. The PURGE3, MIX1, and MIX2 subroutines, written in FORTRAN IV to be run on the IBM 360 computer system, are used for the generation of pseudo-random numbers from a family of Pearson distributions as well as from any combination of mixtures of two Pearson distributions, a normal distribution with arbitrary mean and variance and a uniform distribution on any finite interval. The primary improvement undertaken here was to increase the efficiency of operation by enabling the PURGE3 and MIX1 subroutines to be called in a single computer program. The Pearson distribution may be specified either by the first four moments or from sample data. The parameters of the fitted distribution are printed and, if desired, the moments and a graph of the distribution of the 100 pseudo-random numbers generated are printed. A graph of the mixture of distributions generated in the MIX1 subroutine may be obtained from 10,000 random numbers generated from the mixture. The MIX2 subroutine functions to generate random numbers only. The speed of generation varies from about 13,000 random numbers per minute for a Pearson distribution which computes and prints the moments from the generated numbers, to approximately 143,000 numbers per minute if mixtures are used without computing the moments from the generated numbers. / Master of Science

This thesis describes a system that allows the designer of an interface between humans and computers to implement an English-like set of commands easily. Designers model commands on imperative English sentences containing verbs, direct and indirect objects, adverbs, adjectives, and prepositional phrases. The system restricts the ordering and presence command components as little as possible while still allowing the commands to be analyzed in a deterministic manner. Thus, commands formed with the system can mirror not only the form of English, but the flexibility of English as well. This system is based on the macro expansion of a command into a base language, and therefore has only the expressive power of the base language. Because of this, the system can only aid in the definition of commands, and not in the definition of a language. The language for describing the commands is structural in nature. The programmer defines the parts of a command instead of the syntax of the command. With each part of the command, the programmer defines sections of code that will be generated at various points during the recognition of the command. An implementation can execute generated code at some later time, at the end of the translation, or during the expansion. A prototype implementation expands of a file of commands into the VAX/VMS Digital Command Language. / M.S.

The thesis describes the requirement, design, and implementation of a software package that can be used to perform quantitative studies on certain aspects of a programming task. Of specific interest are experiments with the level of interactiveness of the human-computer interface relating to program construction and with language design principles relating to identifier scope rules. The software package for conducting these experiments is an interactive language environment called PEEP. Its base language is Pascal and its design is based on Johnston's semantic models of computation. Storage representations and implementation of these semantic models are described. These models depicting the compile-time structure, run-time structure, and realization of the static and the dynamic scoping rules. The evolution and current research of programming environments, user interface to PEEP, and future research on PEEP are also focuses of attention. / Master of Science

An expressive type language and the ability to do compile-time type inference are desirable goals in language design, but the attainment of the former may preclude the possibility of the latter. Specifically, the type conjunction operator (type intersection) induces a rich type language at the expense of decidability of the typeable expressions. Two extreme alternatives to this dilemma are to abandon type inference (and force the programmer to, essentially, supply a derivation for his type claims) or to abandon (or restrict) type conjunction. This work presents a third alternative in which the programmer, at times, may be required to supply explicit types in order for type inference to succeed. In this way, the power of conjunctive types is preserved, yet compile-time type inference can be done for a large class of polymorphic functions, including those typeable with parametric types. To this end, we introduce a simple combinator based language with typing rules based on type conjunction and a subtype relation, of sorts, called "weaker." The validity of the type rules with respect to the usual interpretation of "type" is shown, along with the undecidability of the type relation. It is shown how the computational portion of the language can be modified to accommodate explicit type information which may direct an automatic type derivation. This new language has the principal type property with respect to a decidable relation, although deciding this relation is shown to be an NP-Complete problem. The language is extended to accommodate type fixed points, and extended further to allow all expressions with parametric types to be typed automatically, and to accommodate integers, pairs, sums, and abstract types in the form of type generators. / Ph. D.

The research reported in this dissertation investigates extending the power and flexibility of an object-oriented language with inheritance, Static typing, and concurrency. A language supporting inheritance, static typing, and concurrency offers a significant leverage in software development. However, when these features are provided together, the benefits of the features are significantly reduced due to the interaction among them. The challenge for the designer of an object-oriented language lies in the difficulty of reconciling the conflicts among these features. This thesis discusses two issues: combining static typing with inheritance and combining concurrency with inheritance. A new model of type and inheritance, called HANA, is presented. The HANA model integrates multiple inheritance, multiple representation, method exclusion, and method name overloading with static typing. The contribution of HANA is that it extends other existing models of type and inheritance with enhanced expressive power, increased reusability, and improved program efficiency. Combining concurrency with inheritance is investigated in the framework of the actor computation model. A language design based on the actor model of concurrent computation faces a serious problem arising from the interference between concurrency and inheritance. A similar problem also occurs in other concurrent object-oriented languages. The problem of concurrency-inheritance conflict is described and a solution based on a concept called behavior abstraction is presented. / Ph. D.

For many embedded applications, the timing of a result is as important as its value. However, most programming languages treat timing as a side effect, so they cannot convey temporal behavior without compromising precision, efficiency, or flexibility. This dissertation presents the Sparse Synchronous Model (SSM), a programming model for building temporal abstractions with high-level languages. SSM is deterministic and defines behavior in terms of logical time, but is more expressive than the synchronous languages it was inspired by. It uses the same abstractions for internal events and external I/O, so the meaning of each program is preserved across different platforms. The main contributions of this work are the formal semantics of SSM, and SSLANG, a standalone functional programming language that implements SSM and runs on microcontrollers. SSLANG's runtime keeps the software synchronized with the real world, and uses timing-aware hardware peripherals to achieve jitter-free I/O with sub-microsecond precision. The dissertation also describes two embeddings of SSM in existing languages to show that the model is compatible with conventional programming paradigms. Together, these results illustrate the value of extensible, timing-aware programming abstractions for building reliable real-time systems.

Abstraction mechanisms in programming languages aim to allow orthogonal pieces of functionality to be developed separately; complex software can then be constructed through the composition of these pieces. The effectiveness of such mechanisms lies in their support for modularity and reusability: The behavior of a piece of code should be reasoned about modularly---independently of the specific compositions it may participate in; the computation of a piece of code should allow specialization, so that it is reusable for different compositions. This dissertation introduces structural abstraction: a mechanism that advances the state of the art by allowing the writing of highly reusable code---code whose structure can be specialized per composition, while maintaining a high level of modularity. Structural abstraction provides a disciplined way for code to inspect the structure of its clients in composition, and declare its own structure accordingly. The hallmark feature of structural abstraction is that, despite its emphasis on greater reusability, it still allows modular type checking: A piece of structurally abstract code can be type-checked independently of its uses in compositions---an invaluable feature for highly reusable components that will be statically composed by other programmers. This dissertation introduces two structural abstraction techniques: static type conditions, and morphing. Static type conditions allow code to be conditionally declared based on subtyping constraints. A client of a piece of code can configure a desirable set of features by composing the code with types that satisfy the appropriate subtyping conditions. Morphing allows code to be iteratively declared, by statically reflecting over the structural members of code that it would be composed with. A morphing piece of code can mimic the structure of its clients in composition, or change its shape according to its clients in a pattern-based manner. Using either static type conditions or morphing, the structure of a piece of code is not statically determined, but can be automatically specialized by clients. Static type conditions and morphing both guarantee the modular type-safety of code: regardless of specific client configurations, code is guaranteed to be well-typed.

HOLCF is an interactive theorem proving system that uses the mathematics of domain theory to reason about programs written in functional programming languages. This thesis introduces HOLCF '11, a thoroughly revised and extended version of HOLCF that advances the state of the art in program verification: HOLCF '11 can reason about many program definitions that are beyond the scope of other formal proof tools, while providing a high degree of proof automation. The soundness of the system is ensured by adhering to a definitional approach: New constants and types are defined in terms of previous concepts, without introducing new axioms. Major features of HOLCF '11 include two high-level definition packages: the Fixrec package for defining recursive functions, and the Domain package for defining recursive datatypes. Each of these uses the domain-theoretic concept of least fixed points to translate user-supplied recursive specifications into safe low-level definitions. Together, these tools make it easy for users to translate a wide variety of functional programs into the formalism of HOLCF. Theorems generated by the tools also make it easy for users to reason about their programs, with a very high level of confidence in the soundness of the results. As a case study, we present a fully mechanized verification of a model of concurrency based on powerdomains. The formalization depends on many features unique to HOLCF '11, and is the first verification of such a model in a formal proof tool.

<p>Given the nature of client-server applications, most use some freeform interface, like web forms, to collect user input. The main difficulty with this approach is that all parameters obtained in this fashion need to be validated and normalized to protect the application from invalid entries. This is the problem addressed here: how to take client input and preprocess it before passing the data to a back-end, which concentrates on business logic. The method of implementation is a rule engine that uses Groovy internal domain-specific language (DSL) for specifying input requirements. We will justify why the DSL is a good fit for a validation rule engine, describe existing techniques used in this area and comprehensively address the related issues of accidental complexity, security, and user experience.</p> / Master of Science (MSc)