876 research outputs found
The Design, construction, and implementation of an engineering software command processor and macro compiler
This paper presents the design and construction of a software translator that serves as a foundation, or central engine, around which an entire engineering software system can be constructed. To provide the user with a powerful interface to drive an application, a high-level procedural language similar to FORTRAN or BASIC is integrated into the translator. An application shell was also written to provide the user with an interactive command line environment for using the translator. The translator, language, and application shell together mechanize a programming and command interpreter environment. Users can interactively enter commands from the keyboard or load and process pre-written macro files from disk. The language gives users the ability to create variables, arrays, and functions, process complex mathematical expressions, and develop sophisticated macro programs. The language is quite capable of solving very complex engineering problems. Several engineering examples are presented including a solution to a four-bar crank mechanism, adding a material library to an application, a command line integration solver, a Runge-Kutta routine for solving sets of differential equations, and a convolution integral routine. The translator is modular, easily extensible, written entirely in C/C++, and readily portable to different platforms. A set of diagnostic tools is integrated into the translator to aid the developer in future development work. Complete theory and design details for all phases of the translator and language are presented. Performance issues are studied including a comparison against C/C++ and MS-DOS Qbasic. Exploration in application integration for a simulation package similar to CSMP is investigated. A complete Language and Compiler Guide is supplied with the program
Building Web Based Programming Environments for Functional Programming
Functional programming offers an accessible and powerful algebraic model for computing. JavaScript is the language of the ubiquitous Web, but it does not support functional programs well due to its single-threaded, asynchronous nature and lack of rich control flow operators. The purpose of this work is to extend JavaScript to a language environment that satisfies the needs of functional programs on the Web. This extended language environment uses sophisticated control operators to provide an event-driven functional programming model that cooperates with the browser\u27s DOM, along with synchronous access to JavaScript\u27s asynchronous APIs. The results of this work are used toward two projects: (1) a programming environment called WeScheme that runs in the web browser and supports a functional programming curriculum, and (2) a tool-chain called Moby that compiles event-driven functional programs to smartphones, with access to phone-specific features
Theory and practice in the construction of efficient interpreters
Various characteristics of a programming language, or of the hardware on which it is to be
implemented, may make interpretation a more attractive implementation technique than compilation
into machine instructions. Many interpretive techniques can be employed; this thesis is mainly
concerned with an efficient and flexible technique using a form of interpretive code known as
indirect threaded code (ITC). An extended example of its use is given by the Setl-s implementation
of Setl, a programming language based on mathematical set theory. The ITC format, in which pointers
to system routines are embedded in the code, is described and its extension to cope with
polymorphic operators. The operand formats and some of the system routines are described in detail
to illustrate the effect of the language design on the interpreter.
Setl must be compiled into indirect threaded code and its elaborate syntax demands the use of a
sophisticated parser. In Setl-s an LR(1) parser is implemented as a data structure which is
interpreted in a way resembling that in which ITC is interpreted at runtime. Qualitative and
quantitative aspects of the compiler, interpreter and system as a whole are discussed.
The semantics of a language can be defined mathematically using denotational semantics. By setting
up a suitable domain structure, it is possible to devise a semantic definition which embodies the
essential features of ITC. This definition can be related, on the one hand to the standard
semantics of the language, and on the other to its implementation as an ITC-based interpreter. This
is done for a simple language known as X10. Finally, an indication is given of how this approach
could be extended to describe Setl-s, and of the insight gained from such a description. Some
possible applications of the theoretical analysis in the building of ITC-based interpreters are
suggested
Advanced data management system analysis techniques study
The state of the art of system analysis is reviewed, emphasizing data management. Analytic, hardware, and software techniques are described
Recommended from our members
Evaluation of Corba for use in distributed control systems
The Common Object Request Broker Architecture (CORBA)-based Simulator was a Laboratory Directed Research and Development (LDRD) project that applied simulation techniques to explore critical questions about advanced distributed control system architectures. A three-prong approach comprised of a study of object-oriented distribution tools, computer network modeling, and simulation of key control system scenarios was used in the LDRD project. This input report describes the first of the three approaches Ñ the study of object-oriented distribution tools together with measurements, and predictions of use within the National Ignition Facility (NIF) and some aspects of CORBA which remain to be resolved. For the ICCS, the completeness of suitable functionality, the speed of performance and utilization of machine and network resources, and the developing nature of the commercial CORBA products themselves, presented a certain risk. This LDRD thus evaluated CORBA in general, and a particular implementation, to determine its features, performance, and scaling properties, and to optimize its use within the ICCS. Both UNIX and real-time operating systems were studied
Automation of garment assembly processes
Robotic automation in apparel manufacturing is reviewed and investigated. Gripper design for separation and de-stacking of batch cut fabric components is identified as an important factor in implementing such automation and a study of existing gripper mechanisms is presented. New de-stacking gripper designs and processes are described together with experimental results. Single fabric component handling, alignment and registration techniques are investigated. Some of these techniques are integrated within a demonstrator robotic garment assembly cell automating the common edge binding process. Performance results are reported
Production of optimised machine-code for high-level languages using machine-independent intermediate codes
The aim of this work was to investigate the problems
associated with using machine-independent intermediate
codes in the translation from a high-level language into
machine code, with emphasis on minimising code size and
providing good run-time diagnostic capabilities.
The main result was a machine-independent intermediate
code, I-code, which has been used successfully to develop
optimising and diagnostic compilers for the IMP77 language
on a large number of different computer systems. In
addition, the work has been used to lay the foundations
for a project to develop an intermediate code for portable
SIMULA compilers.
The major conclusions of the research were that
carefully designed machine-independent intermediate codes
can be used to generate viable optimising and diagnostic
compilers, and that the commonality introduced into
different code generators processing the code for
different machines simplifies the tasks of creating new
compilers and maintaining old ones
- …