by Brian Cantwell Smith.; Thesis (Ph.D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1982.; MICROFICHE COPY AVAILABLE IN ARCHIVES AND ENGINEERING.; Bibliography: leaves 756-761.
The Emerging Notification Oriented Paradigm (NOP) is materialized in a Framework developed in the C++ language programming. The NOP Framework was designed to provide an Application Programming Interface (API) and high-level structures that would facilitate the development of software according to their orientation. However, this implies to a computational processing overhead of each NOP application. Still, an embryonic friendly Interface called Wizard was designed to provide high-level resource for the development of certain NOP applications. Thus, this work proposes a new version of materialization of NOP Framework and the evolution of its Wizard Interface. At the end, these are validated by quantitative and qualitative comparisons, in a relation to its previous artifacts. The quantitative comparisons are referent of the performance to the Framework instances, whereas the qualitative comparisons are about the facilities of yours compositions.; O emergente Paradigma Orientado a Notificações (PON) está materializado em um Framework desenvolvido na linguagem de programação C++. Este foi projetado para fornecer uma Application Programming Interface (API) e estruturas de alto nível que facilitasse o desenvolvimento de software segundo sua orientação. Entretanto...
This thesis presents a new method for performing incremental code generation in a distributed integrated programming environment. A prototype implementation of such an incremental code generator is also described. The study derives a new retargetable incremental instruction algorithm from a non-incremental instruction selection technique in the framework of a precise model of the underlying program representation. The resulting algorithm incrementally regenerates locally optimal object code after the replacement of a subtree in an abstract syntax tree program representation.; Thesis (Ph.D.)--University of Adelaide, Dept. of Computer Science, 1996; Bibliography: leaves 215-229.; viii, 229 leaves ; 30 cm.; Title page, contents and abstract only. The complete thesis in print form is available from the University Library.
Thesis (Ph.D.)--University of Adelaide, Dept. of Computer Science, 1984; Bibliography: leaves 187-194; 194 leaves : ill ; 30 cm.; Title page, contents and abstract only. The complete thesis in print form is available from the University Library.
Thesis (Ph.D.)--University of Adelaide, Dept. of Computer Science, 1985; Bibliography: leaves -244; xi, 244 leaves : ill ; 30 cm.; Title page, contents and abstract only. The complete thesis in print form is available from the University Library.
There are many software database management systems available on many general-purpose computers ranging from micros to super-mainframes. Database machines as backened computers can offload the database management work from the mainframe so that we can retain the same mainframe longer. However, the database backend must also demonstrate lower cost, higher performance, and newer functionality. Some of the fundamental architecture issues in the design of high-performance and great-capacity database machines are addressed. Solutions towards resolving these design issues are articulated. This article is written for the New York University's Symposium in New Directions of Database Systems on the basis of a lecture given at Microelectronic and Computer Technology, Inc. (MCC); Prepared for: Chief of Naval Research; http://archive.org/details/futuredatabasema00hsia; N00014-84-WR-24058; NA
This report describes the concurrent execution and synchronization facilities of a prototype systems implementation language for Intel's iAPX-432 microprocessor. Full exploitation of the 432's facilities places many demands on a language intended for systems implementation. This report describes the prototype languages support for the 432's dynamic, message-based model of concurrency. (Author); supported in part by the Foundation
Research Program of the Naval Postgraduate School with funds provided by the Chief of Naval Research.; http://archive.org/details/concurrencysynch00macl; Chief of Naval Research; NA
Object oriented programming is a way of abstracting information and operations to make programming more efficient and reliable. C is a non object oriented programming language that has become a de facto language standard in academic and industrial applications because of its power and flexibility. ClassC is an attempt to add object orientation on the existing framework that C provides. Specifically, ClassC adds the new data type object, and the new aggregate declaration, class.
ClassC differs from other C-based object oriented languages such as C++
Objective-C in three points:
1) ClassC provides true multiple inheritance, which is very commonly discussed in the description of object oriented languages, but very rarely actually implemented.
2) ClassC provides both strict type checking on objects as well as typeless dynamic binding a variable of type object may be assigned any class instantiation. Dynamic binding is typical of interpreted languages like lisp and Smalltalk, but rare in compiled languages like C and Pascal, etc.
3) ClassC offers automatic garbage collection of memory no longer referenced by any object variables.
ClassC/Elaine is intended to be a flexible system that allows programmers to explore different qualities of object oriented programming...
Classes in C++ provide static encapsulation of objects, by generating code
which contains specific knowledge about the internals of encapsulated objects.
Static encapsulation occurs at compile time, and therefore cannot directly support
the evolution of objects, since recompilation of source code is required if the
internal layout changes. This also prohibits the use of distributed or persistent
objects without first ensuring that the internal representations of the objects
match the ones in the compiled code.
Dynamic encapsulation occurs at run-time, and allows the compiled code
to exist without the knowledge of any particular object representation. Abstract
base classes with C++ virtual functions support a limited form of dynamic encapsulation, but only for objects originally designated to inherit from those classes.
Some languages, such as Smalltalk, support dynamic encapsulation, but with significantly less performance than statically encapsulated languages.
An object model using dynamic type-binding is presented which allows the
flexibility of dynamic encapsulation with much of the efficiency of static encapsulation. With this model, objects can potentially communicate and migrate
across address space and network boundaries without specific prior knowledge of
Modula 2 has been proposed as an appropriate language
for systems programming. Smaller than PASCAL but
more structured than 'C\ Modula 2 is intended to be
relatively easy to implement. A realization of a subset
of Modula 2 for the MC68010 microprocessor is
presented. Widely available UNIX tools and the 'C
language are used for the implementation. A
mechanism for calling 'C language functions from
Modula 2 (and vice versa) is suggested. Critical source
code, grammar, and an extensive bibliography pertinent
to the implementation are included as appendices.
In an effort to provide better computer programming instruction to more students at an
introductory level, pedagogical methods could be improved using a paradigm of instruction
based on the same strategies used to teach students spoken languages. Although many different
methodologies of instruction have been explored in the past, this document identifies
relationships between spoken languages and computer languages that encourage the exploration
of the best practices of teaching English Language Arts so that they could be applied to computer
Those with backgrounds in mathematics and science initially completed programming tasks.
Much literature about the problem solving aspects of programming is available; however, the
researcher of this document found it difficult to obtain literature about the opportunities for
growth provided by the humanities. This research is an attempt to foster the programming skills
of students based on language skills. Given the similarities between spoken languages and
object-oriented programming languages that have emerged, there is much encouragement that
there may be possibilities for a new instructional paradigm.
Following is an analysis of how computer languages are taught and how English is taught...
A language CONCUR is defined which permits the definition and initiation of asynchronous processes. The language was inspired by Modula, a language proposed by Wirth for realtime programming. CONCUR removes Modula's restrictions on the placement of process declarations and invocations in order to study the implications of process support more fully- Most of the other sophisticated features of Modula, such as modules, structure types, and procedures, have also been removed to focus attention on processes and their particular requirements. A general methodology is suggested for concurrent programming, and several sample programs are presented which demonstrate concurrent programming with CONCUR. Finally, a compiler is presented which translates CONCUR into the object language for a hypothetical machine. An interpreter for this object language is also included.
The concept of visual programming languages is described and some necessary terms are defined. The value of visual languages is presented and a number of different visual languages are described. Various issues, such as user interface design, are discussed. As an example of a visual programming language, a graphical data flow programming environment is developed for the Macintosh workstation which functions as a preprocessor to a data flow simulator developed at RIT. Examples are presented demonstrating the use of the language environment. Issues related to the development of the programming environment are described and conclusions regarding the development of visual programming languages in general are presented.
Imperative programming languages were initially built for uniprocessor systems that evolved out of the Von Neumann machine model. This model of storage oriented computation blocks parallelism and increases the cost of parallel
program development and porting. Declarative languages based on mathematical models of computation, seem more suitable for the development of parallel
In the first part of this thesis we examine different language families under
the declarative paradigm: functional, logic, and constraint languages.
Functional languages are based on the abstract model of functions and (lamda)-calculus.
They were initially developed for symbolic computation, but today
they are commonly used in numerical analysis and many other application areas.
Pure lisp is a widely known member of this class.
Logic languages are based on first order predicate calculus. Although they
were initially developed for theorem proving, fifth generation operating systems
are written in them. Most logic languages are descendants or distant relatives
Constraint languages are related to logic languages. In a constraint language
you define a program object by placing constraints on its structure and its behavior. They were initially used in graphics applications...
XSLT is a transform language for XML that is defined over XML. In other words, XSLT is a language that
performs transforms on XML documents, and XSLT programs are themselves XML documents. While XSLT is by
nature a functional language, its definition as an XML application obfuscates this fact . Previous research projects
have taken the XML-Infoset and provided an alternate syntax in the form of S-expressions, along with providing
languages to perform transformations of the new representation in manners similar to that of XSLT. For example,
SXML / SXSLT performs this function by embedding said languages in Scheme .
XLove applies modern principles of object-oriented design, namely design patterns, to this problem. Xl is an
alternate syntax for the XML-Infoset. It maintains a clear distinction between attributes and elements (while having
a concise notation for namespaces). The syntax is built into a representation over the Document Object Model by
observers responding to parsing events. Xlt is an alternate syntax for XSLT designed to emphasize the functional
nature of the language. A set of visitors transforms the input Document Object Model tree into an output tree by
mapping the Xlt abstract syntax tree to XSLT. The resultant document is a valid XSLT program over the Document
Object Model which can than be directly executed or output as an XML file.
For decades humans have been searching for the test way to communicate with an intelligent machine, a computer. Several programming languages have been written with the idea of a universal language have been written with the idea of a universal language which includes solutions to solve as many problems as one can think of. Put the more universal the languages are the more complex they are to study.
Henery Ledgard tried to combine these two ideas together. He suggests the idea of studying programming language by dealing with a few key features at a time. He separated the various programming features. grouped the similar ones together and wrote his own small languages called "Mini-languages".
The programming language landscape' (15) which includes 13 mini-languages was used as the central reference for this thesis work. Each of the four mini-languages was implemented in 2 sections; a compiler and an interpreter. One can write a program in any of the four mini-languages; compile and run (interpret) it to test the correctness.
The Gshell, a graphical command interpreter for Unix, and an executing
and editing environment far the Gshell system are described. Through the
use of a pictorial representation of command scripts the Gshell system provides a more powerful expression of concurrency than is possible with conventional Unix command languages. Its syntax and use is explained and
major features of its underlying control and data structures are discussed
from the point of view of the designer and the programmer.