Compiling knowledge-based systems from KEE to Ada

The dominant technology for developing AI applications is to work in a multi-mechanism, integrated, knowledge-based system (KBS) development environment. Unfortunately, systems developed in such environments are inappropriate for delivering many applications - most importantly, they carry the baggage of the entire Lisp environment and are not written in conventional languages. One resolution of this problem would be to compile applications from complex environments to conventional languages. Here the first efforts to develop a system for compiling KBS developed in KEE to Ada (trademark). This system is called KATYDID, for KEE/Ada Translation Yields Development Into Delivery. KATYDID includes early prototypes of a run-time KEE core (object-structure) library module for Ada, and translation mechanisms for knowledge structures, rules, and Lisp code to Ada. Using these tools, part of a simple expert system was compiled (not quite automatically) to run in a purely Ada environment. This experience has given us various insights on Ada as an artificial intelligence programming language, potential solutions of some of the engineering difficulties encountered in early work, and inspiration on future system development

The C++0x "Concepts" Effort

C++0x is the working title for the revision of the ISO standard of the C++ programming language that was originally planned for release in 2009 but that was delayed to 2011. The largest language extension in C++0x was "concepts", that is, a collection of features for constraining template parameters. In September of 2008, the C++ standards committee voted the concepts extension into C++0x, but then in July of 2009, the committee voted the concepts extension back out of C++0x. This article is my account of the technical challenges and debates within the "concepts" effort in the years 2003 to 2009. To provide some background, the article also describes the design space for constrained parametric polymorphism, or what is colloquially know as constrained generics. While this article is meant to be generally accessible, the writing is aimed toward readers with background in functional programming and programming language theory. This article grew out of a lecture at the Spring School on Generic and Indexed Programming at the University of Oxford, March 2010

ART/Ada design project, phase 1. Task 1 report: Overall design

The design methodology for the ART/Ada project is introduced, and the selected design for ART/Ada is described in detail. The following topics are included: object-oriented design, reusable software, documentation techniques, impact of Ada, design approach, and differences between ART-IM 1.5 and ART/Ada 1.0 prototype. Also, Ada generator and ART/Ada runtime systems are discussed

Parameter Estimation of K-Distributed Clutter Based on Fuzzy Inference and Gustafson-Kessel Clustering

The detection performance of maritime radars is restricted by the unwanted sea echo or clutter which is the vector sum of scattering from the sea surface. The echo is noise-like and is expected from a set of randomly moving scatters. Although the number of these target-like data is small, they may cause false alarm in maritime radar and perturb the target detection. K-distribution is known as the best fitted probability density function for the radar sea clutter. The accurate and fast parameter estimation of K-distribution for small number of sea clutter radar data is crucial task to avoid irreparable disasters. A novel approach to estimate the parameters of K-distribution based on fuzzy inference has been proposed in the thesis. Takagi-Sugeno Kang (TSK) model has been chosen since human knowledge is unavailable to be captured, whereas the sea clutter for specific parameter can be easily generated. GK- clustering has been used in order to identify the membership function of the antecedent parts. Least Square Method has been utilized to estimate the parameter of the K-distribution, which is represented in the consequent part of the fuzzy inference system. For a real-time implementation of the proposed method, vectorized programming technique has been implemented. In comparison with the conventional methods, this technique has less computational complexity, needs lesser time to train and estimates faster than any existing methods. Since the method is clustering based, some kind of pre-knowledge (rough estimation) is naturally stored in the structure of the TSK-fuzzy system and Least Square provides a mechanism to fine tune the consequent parameters. The novelty of the proposed method is the incorporation of the clustering (as a pre-estimator) with the estimation process. The resultant estimator then overcomes the bottleneck of the existing methods and is capable of handling even a small number of data

Implementing Overloading and Polymorphism in Cforall

The programming language Cforall extends the C language with, among other things, overloading, parametric polymorphism, and functions that can return multiple values from a single call. This thesis presents an outline of the first implementation of the core Cforall language. An effective implementation of Cforall requires complete support for new language constructs while preserving the behaviour and efficiency of existing C programs. Analyzing the meaning of Cforall programs requires significantly more sophisticated techniques than are necessary for C programs; existing techniques for the analysis of overloading and polymorphism are adapted and extended to apply to Cforall. Three strategies for generating code for polymorphic programs are compared, using plain C as an intermediate representation. Finally, a realistic Cforall program is presented and characteristics of the generated C code are examined

Dynamically typed languages

Dynamically typed languages such as Python and Ruby have experienced a rapid grown in popularity in recent times. However, there is much confusion as to what makes these languages interesting relative to statically typed languages, and little knowledge of their rich history. In this chapter I explore the general topic of dynamically typed languages, how they differ from statically typed languages, their history, and their defining features

An Approach to Overloading With Polymorphism

One of the principal characterising features of a programming language is its type system. Many recent functional programming languages adopt a Hindley-Milner style type system facilitating parametric polymorphism. One of the forms of polymorphism found most commonly in programming languages is overloading. Whereas one may consider the Hindley-Milner system an off-the-shelf package for parametric polymorphism, there is no similar uniformity in the approaches taken to overloading. This thesis extends the standard Hindley-Milner system. A type system incorporating parametric polymorphism and overloading is presented both formally and informally, and it is shown to satisfy a principal type theorem. The Hindley-Milner type inference algorithm is extended for the new system. This algorithm is shown to be sound and complete. The characteristic feature of parametric polymorphism is that the same code can be used at many different types. The corresponding characterisation rule for overloading is that different code is used at different types. As such, meaning is assigned to terms on the basis of their typing. The semantics of the form of overloading described herein is assigned by means of a derivation to derivation translation scheme. This scheme is shown to be sound and, under certain well-defined conditions, coherent. This approach to overloading is closely related to the lazy functional programming language Haskell's type class mechanism. Some discussion of matters related to the current system, and arising through that project, is given

The design and implementation of a relational programming system.

The declarative class of computer languages consists mainly of two paradigms - the logic and the functional. Much research has been devoted in recent years to the integration of the two with the aim of securing the advantages of both without retaining their disadvantages. To date this research has, arguably, been less fruitful than initially hoped. A large number of composite functional/logical languages have been proposed but have generally been marred by the lack of a firm, cohesive, mathematical basis. More recently new declarative paradigms, equational and constraint languages, have been advocated. These however do not fully encompass those features we perceive as being central to functional and logic languages. The crucial functional features are higher-order definitions, static polymorphic typing, applicative expressions and laziness. The crucial logic features are ability to reason about both functional and non-functional relationships and to handle computations involving search. This thesis advocates a new declarative paradigm which lies midway between functional and logic languages - the so-called relational paradigm. In a relationallanguage program and data alike are denoted by relations. All expressions are relations constructed from simpler expressions using operators which form a relational algebra. The impetus for use of relations in a declarative language comes from observations concerning their connection to functional and logic programming. Relations are mathematically more general than functions modelling non-functional as well as functional relationships. They also form the basis of many logic languages, for example, Prolog. This thesis proposes a new relational language based entirely on binary relations, named Drusilla. We demonstrate the functional and logic aspects of Drusilla. It retains the higher-order objects and polymorphism found in modern functional languages but handles non-determinism and models relationships between objects in the manner of a logic language with notion of algorithm being composed of logic and control elements. Different programming styles - functional, logic and relational- are illustrated. However, such expressive power does not come for free; it has associated with it a high cost of implementation. Two main techniques are used in the necessarily complex language interpreter. A type inference system checks programs to ensure they are meaningful and simultaneously performs automatic representation selection for relations. A symbolic manipulation system transforms programs to improve. efficiency of expressions and to increase the number of possible representations for relations while preserving program meaning

Polymorphism and Type Inference in Database Programming

The polymorphic type system of ML can be extended in two ways that make it appropriate as the basis of a database programming language. The first is an extension to the language of types that captures the polymorphic nature of field selection; the second is a technique that generalizes relational operators to arbitrary data structures. The combination provides a statically typed language in which relational databases may be cleanly represented as typed structures. As in ML types are inferred, which relieves the programmer of making the rather complicated type assertions that may be required to express the most general type of a program that involves field selection and generalized relational operators. It is also possible to use these ideas to implement various aspects of object-oriented databases. By implementing database objects as reference types and generating the appropriate views - sets of structures with identity - we can achieve a degree of static type checking for object-oriented databases. Moreover it is possible to exploit the type system to check the consistency of object-oriented classes (abstract data types with inheritance). A prototype language based on these ideas has been implemented. While it lacks some important practical features, it demonstrates that a wide variety of database structures can be cleanly represented in a polymorphic programming language