Automated Engineering Design (AED); An approach to automated documentation

The automated engineering design (AED) is reviewed, consisting of a high level systems programming language, a series of modular precoded subroutines, and a set of powerful software machine tools that effectively automate the production and design of new languages. AED is used primarily for development of problem and user-oriented languages. Software production phases are diagramed, and factors which inhibit effective documentation are evaluated

Representing grammar, meaning and knowledge

Among the expertises relevant for successful natural language understanding are grammar, meaning and background knowledge, all of which must be represented in order to decode messages from text (or speech). The present paper is a sketch of one cooperation of grammar and meaning representations -- with some remarks about knowledge representation -- which allows that the representations involved be heterogeneous even while cooperating closely. The modules cooperate in what might be called a PLURALIST fashion, with few assumptions about the representations involved. In point of fact, the proposal is compatible with state-of-the-art representations from all three areas. The paper proceeeds from the nearly universal assumption that the grammar formalism is feature-based and insufficiently expressive for use in meaning representation. It then demonstrates how feature formalisms may be employed as a semantic metalanguage in order that semantic constraints may be expressed in a single formalism with grammatical constraints. This allows a tight coupling of syntax and semantics, the incorporation of nonsyntactic constraints (e.g., from knowledge representation) and the opportunity to underspecify meanings in novel ways -- including, e.g., ways which distinguish ambiguity and underspecification (vagueness). We retain scepticism vis-à-vis more ASSIMILATIONIST proposals for the interaction of these -- i.e., proposals which foresee common formalisms for grammar, meaning and knowledge representation. While such proposals rightfully claim to allow for closer integration, they fail to account for the motivations which distinguish formalisms - elaborate expressive strength in the case of semantic representations, monotonic (and preferably decidable) computation in the case of grammar formalisms, and the characterization of taxonomic reasoning in the case of knowledge representation

Static Computation and Reflection

Thesis (PhD) - Indiana University, Computer Sciences, 2008Most programming languages do not allow programs to inspect their static type information or perform computations on it. C++, however, lets programmers write template metaprograms, which enable programs to encode static information, perform compile-time computations, and make static decisions about run-time behavior. Many C++ libraries and applications use template metaprogramming to build specialized abstraction mechanisms, implement domain-specific safety checks, and improve run-time performance. Template metaprogramming is an emergent capability of the C++ type system, and the C++ language specification is informal and imprecise. As a result, template metaprogramming often involves heroic programming feats and often leads to code that is difficult to read and maintain. Furthermore, many template-based code generation and optimization techniques rely on particular compiler implementations, rather than language semantics, for performance gains. Motivated by the capabilities and techniques of C++ template metaprogramming, this thesis documents some common programming patterns, including static computation, type analysis, generative programming, and the encoding of domain-specific static checks. It also documents notable shortcomings to current practice, including limited support for reflection, semantic ambiguity, and other issues that arise from the pioneering nature of template metaprogramming. Finally, this thesis presents the design of a foundational programming language, motivated by the analysis of template metaprogramming, that allows programs to statically inspect type information, perform computations, and generate code. The language is specified as a core calculus and its capabilities are presented in an idealized setting

A visual analytics architecture for the analysis and understanding of software systems

Visual analytics facilitates the creation of knowledge to interpret trends and relationships for better decision making. However, it has not being used widely for the understanding of software systems and the change process that takes place during their development and maintenance. This occurs despite the need of project managers and developers to analyze their systems to calculate the complexity, cohesion, direct, indirect and logical coupling, detect clones, defects and bad smells, and the comparison of individual revisions. This research considers the design of an extensible and scalable architecture to incorporate new and existing methods to retrieve source code from different versioning systems, to carry out the analysis of programs in different languages, to perform the calculation of software metrics and to present the results using visual representations, incorporated as Eclipse and Visual Studio extensions. Consequently, the aim of this work is to design a visual analytics architecture for the analysis and understanding of systems in different languages and its main contributions are the specification of the design and requirements of such architecture, taking as base the lessons learned in Maleku (A. González-Torres et al., 2016)

THE ROLE OF XML IN THE MODELING PROCESS OF A VIRTUAL BUSINESS

The aim of this paper is to describe the XML stack of languages used in the implementation process of a web application. This application is based on a three tier architecture named XRX. In this type of architecture there is no need for data model transformations between the tiers of the architecture like in the classical architecture. So the applications developed according XRX architecture become more flexible, efficient and simple.XML, XPath, XQuery, XSLT, XForms, XRX, UBL

A feature-based syntax/semantics interface

Syntax/Semantics interfaces using unification-based or feature-based formalisms are increasingly common in the existing computational linguistics literature. The primary reason for attempting to specify a syntax/semantics interface in feature structures is that it harmonizes so well with the way in which syntax is now normally described; this close harmony means that syntactic and semantic processing (and indeed other processing, see below) can be as tightly coupled as one wishes - indeed, there need not be any fundamental distinction between them at all. In this paper, we first point out several advantages of the unification-based view of the syntax/semantics interface over standard views. These include (i) a more flexible relation to nonsyntactic constraints on semantics; (ii) a characterization of semantic ambiguity, which in turn provides a framework in which to describe disambiguation, and (iii) the opportunity to underspecify meanings in a way difficult to reconcile with other views. The last point is illustrated with an application to the notorious scope ambiguity problem