You searched for +publisher:"Rice University" +contributor:("Cartwright, Robert").
Showing records 1 – 23 of
23 total matches.
1.
AbdelGawad, Moez A.
NOOP: A mathematical model of object-oriented programming.
Degree: PhD, Engineering, 2012, Rice University
URL: http://hdl.handle.net/1911/70199 
► Computer software is ubiquitous. More than 35 × 10 18 computer instructions are executed around the globe each second. As computers dominate more aspects of…
(more)
▼ Computer software is ubiquitous. More than 35 × 10 18 computer instructions are executed around the globe each second. As computers dominate more aspects of our lives, there is a growing need to reason more accurately about computer software. Most contemporary computer software is written using object-oriented (OO) programming languages, such as J AVA, C#, and C++. How should we mathematically characterize object-oriented software? This is the question this thesis addresses by presenting an accurate domain-theoretic model of mainstream object-oriented programming. Mainstream object-oriented languages are class-based. In such languages, the name of a class is part of the meaning of an object, a property often called "nominality". Most mainstream OO languages also conform to a static type discipline. Hence, the focus of this thesis is the construction of an accurate model of nominal, statically-typed OO languages. In statically-typed nominal OO languages, class names are also part of the meaning of corresponding class types, and class inheritance (subclassing) is explicitly declared; one class is a subclass of another only if it is declared as such. When static type systems are formulated to describe sets of objects, subtyping is defined so that subclassing is consistent with subtyping. Nevertheless, some programming languages (PL) theoreticians dismiss this identification as a design error because the only published models of OO languages exclude nominal information from objects and define subtyping in a way that ignores nominality. In nominal OO languages, program behavior depends on the nominal information embedded in objects. This thesis builds a model of OO languages called NOOP that includes nominal information and defines static types in accord with mainstream OO language designs. In NOOP , the meaning of every object includes its class name. Similarly, types are defined such that objects belong to a particular class type if and only if they are members of classes that inherit from the class corresponding to the class type. To demonstrate the utility of the model, we show that in NOOP inheritance and OO subtyping coincide. This work shows that mainstream OO languages are not technically defective in identifying inheritance and subtyping. In models that include nominal information and define types that respect nominal information, this identification is mathematically correct. The folklore among OO programming language researchers that "inheritance is not subtyping" is incorrect.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Applied sciences; Object-oriented programming; Computer software; Nominal OO languages; Statically-typed OO languages; Applied mathematics; Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
AbdelGawad, M. A. (2012). NOOP: A mathematical model of object-oriented programming. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/70199
Chicago Manual of Style (16th Edition):
AbdelGawad, Moez A. “NOOP: A mathematical model of object-oriented programming.” 2012. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/70199.
MLA Handbook (7th Edition):
AbdelGawad, Moez A. “NOOP: A mathematical model of object-oriented programming.” 2012. Web. 20 Jan 2021.
Vancouver:
AbdelGawad MA. NOOP: A mathematical model of object-oriented programming. [Internet] [Doctoral dissertation]. Rice University; 2012. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/70199.
Council of Science Editors:
AbdelGawad MA. NOOP: A mathematical model of object-oriented programming. [Doctoral Dissertation]. Rice University; 2012. Available from: http://hdl.handle.net/1911/70199
2.
Ricken, Mathias Guenter.
A Framework for Testing Concurrent Programs.
Degree: PhD, Engineering, 2011, Rice University
URL: http://hdl.handle.net/1911/70411
► This study proposes a new framework that can effectively apply unit testing to concurrent programs, which are difficult to develop and debug. Test-driven development, a…
(more)
▼ This study proposes a new framework that can effectively apply unit testing to concurrent programs, which are difficult to develop and debug. Test-driven development, a practice enabling developers to detect bugs early by incorporating unit testing into the development process, has become wide-spread, but it has only been effective for programs with a single thread of control. The order of operations in different threads is essentially non-deterministic, making it more complicated to reason about program properties in concurrent programs than in single-threaded programs. Because hardware, operating systems, and compiler optimizations influence the order in which operations in different threads are executed, debugging is problematic since a problem often cannot be reproduced on other machines. Multi-core processors, which have replaced older single-core designs, have exacerbated these problems because they demand the use of concurrency if programs are to benefit from new processors. The existing tools for unit testing programs are either flawed or too costly. JUnit , for instance, assumes that programs are single-threaded and therefore does not work for concurrent programs; ConTest and rstest predate the revised Java memory model and make incorrect assumptions about the operations that affect synchronization. Approaches such as model checking or comprehensive schedule-based execution are too costly to be used frequently. All of these problems prevent software developers from adopting the current tools on a large scale. The proposed framework (i) improves JUnit to recognize errors in all threads, a necessary development without which all other improvements are futile, (ii) places some restrictions on the programs to facilitate automatic testing, (iii) provides tools that reduce programmer mistakes, and (iv) re-runs the unit tests with randomized schedules to simulate the execution under different conditions and on different machines, increasing the probability that errors are detected. The improvements and restrictions, shown not to seriously impede programmers, reliably detect problems that the original JUnit missed. The execution with randomized schedules reveals problems that rarely occur under normal conditions. With an effective testing tool for concurrent programs, developers can test programs more reliably and decrease the number of errors in spite of the proliferation of concurrency demanded by modern processors.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Applied sciences; Multithreading; Concurrent programming; Scheduling; Computer engineering; Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Ricken, M. G. (2011). A Framework for Testing Concurrent Programs. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/70411
Chicago Manual of Style (16th Edition):
Ricken, Mathias Guenter. “A Framework for Testing Concurrent Programs.” 2011. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/70411.
MLA Handbook (7th Edition):
Ricken, Mathias Guenter. “A Framework for Testing Concurrent Programs.” 2011. Web. 20 Jan 2021.
Vancouver:
Ricken MG. A Framework for Testing Concurrent Programs. [Internet] [Doctoral dissertation]. Rice University; 2011. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/70411.
Council of Science Editors:
Ricken MG. A Framework for Testing Concurrent Programs. [Doctoral Dissertation]. Rice University; 2011. Available from: http://hdl.handle.net/1911/70411
3.
Abdelrahman, Mohamed Mahmoud Hafez Mahmoud.
Analyzing robustness of models of chaotic dynamical systems learned from data with Echo state networks.
Degree: MS, Engineering, 2019, Rice University
URL: http://hdl.handle.net/1911/107733
► Large scale engineering as well as natural systems, such as weather, often have high-dimensional state spaces and exhibit chaotic dynamics. To model the behavior of…
(more)
▼ Large scale engineering as well as natural systems, such as weather, often have high-dimensional state spaces and exhibit chaotic dynamics. To model the behavior of such systems, sets of coupled Partial Differential Equations (PDEs) are formulated and solved using high-performance computing systems. More recently, significant attention has grown toward the use of Artificial Intelligence (AI) and Machine Learning (ML) techniques, in particular, using data-driven modeling to learn fast and accurate surrogate process models trained on high-resolution data obtained from simulations, or observations of chaotic systems. Echo state networks (ESN), a family of recurrent neural network algorithms, have emerged as one of the most promising techniques to learn predictive models of chaotic dynamical systems directly from data.
In spite of their success in learning chaotic dynamical systems from data, there are many open questions. Some of them are practical engineering concerns such as: how to choose training parameters (reservoir size, spectral radius, length of training sequence) for specific problems, how robust the learned models are to variations in data, and in training parameters (initialization of random weights, reservoir size, spectral radius). Others are open theoretical questions such as: why do ESNs work at all, in particular, which aspects of the underlying dynamical systems are captured by the learned reservoirs, and which factors determine the prediction horizon of the learned models. In this thesis, we study these practical and theoretical questions in the context of two models of chaotic dynamical systems, Lorenz63 and Lorenz96, which are prototypes of more complex weather models.
We show that the predictive performance of the learned models is highly sensitive to initial conditions — i.e., for different training sequences all of the same lengths but with different initial states, there is considerable variation in prediction horizon from
0.1 MTU to 3.8 MTU in Lorenz63 and from 0.4 MTU to 2.8 MTU in Lorenz96. We also show that variations in the initialization of (random) input weights and (random) reservoir weights at the start of the training phase yields models with varying prediction horizon for the very same training sequence. We discuss the implications of these findings in the construction of robust ESN models for Lorenz systems. To help explain the observed variations in predictive performance with initial conditions, and to understand when and why ESNs work, we use dimensionality reduction and clustering algorithms to visualize the evolution of high-dimensional reservoir states during training and prediction. Our main finding is that, in a well-trained model, reservoir states mirror the dynamics of the chaotic system from which the data is derived. In particular, we can infer the number of dynamical components from the
non-linear clustering of the reservoir states. In the context of Lorenz63, we show that the sensitivity to initial conditions stems from the locations of the initial condition relative to…
Advisors/Committee Members: Subramanian, Devika (advisor), Cartwright, Robert S. (advisor).
Subjects/Keywords: ESN; chaotic dynamical systems; Lorenz63; Lorenz96; dimensionality reduction; UMAP
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Abdelrahman, M. M. H. M. (2019). Analyzing robustness of models of chaotic dynamical systems learned from data with Echo state networks. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/107733
Chicago Manual of Style (16th Edition):
Abdelrahman, Mohamed Mahmoud Hafez Mahmoud. “Analyzing robustness of models of chaotic dynamical systems learned from data with Echo state networks.” 2019. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/107733.
MLA Handbook (7th Edition):
Abdelrahman, Mohamed Mahmoud Hafez Mahmoud. “Analyzing robustness of models of chaotic dynamical systems learned from data with Echo state networks.” 2019. Web. 20 Jan 2021.
Vancouver:
Abdelrahman MMHM. Analyzing robustness of models of chaotic dynamical systems learned from data with Echo state networks. [Internet] [Masters thesis]. Rice University; 2019. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/107733.
Council of Science Editors:
Abdelrahman MMHM. Analyzing robustness of models of chaotic dynamical systems learned from data with Echo state networks. [Masters Thesis]. Rice University; 2019. Available from: http://hdl.handle.net/1911/107733
4.
Zeng, Yingfu.
Making Hybrid Systems Easier to Model, Simulate, and Visualize.
Degree: PhD, Engineering, 2019, Rice University
URL: http://hdl.handle.net/1911/105397
► Specifying the behavior desired of hybrid systems requires analytical modeling of physical phenomena. Similarly, testing them requires simulation of continuous systems. While numerous tools support…
(more)
▼ Specifying the behavior desired of hybrid systems requires analytical modeling of physical phenomena. Similarly, testing them requires simulation of continuous systems. While numerous tools support later stages of developing simulation codes, there is still a large gap between analytical modeling and running simulation code, which significantly impedes the ability of scientists and engineers to develop novel hybrid systems. The support for partial derivative, in particular, is limited in present mainstream modeling and simulation languages as well as reachability analysis tools for hybrid systems. Either they do not provide such language construct, requiring the modeler to manually transform the model or its correctness is unclear.
In this thesis, we demonstrate that compile-time transformations can improve hybrid system formalisms by supporting partial derivatives and equational constraints. These improvements allow the user to express, among other things, the Euler-Lagrangian equation, and to capture practically relevant constraints that arise naturally in mechanical systems. Achieving this level of expressivity requires using a binding time-analysis (BTA), program differentiation, symbolic Gaussian elimination, and abstract interpretation using interval analysis. We give an operational semantics for the specialization process along with a declarative and algorithmic specifications of the binding-time analysis. A type safety theorem is given to show the correctness of the semantics for specialization. The declarative specification of binding-time analysis is used to prove soundness with respect to the specialization process. We also provide an open-source implementation demonstrating our approach.
Advisors/Committee Members: Cartwright, Robert (advisor), Taha, Walid (committee member).
Subjects/Keywords: Modeling; Simulation; Compile-time Transformation; Hybrid Systems; Binding-time Analysis
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Zeng, Y. (2019). Making Hybrid Systems Easier to Model, Simulate, and Visualize. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/105397
Chicago Manual of Style (16th Edition):
Zeng, Yingfu. “Making Hybrid Systems Easier to Model, Simulate, and Visualize.” 2019. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/105397.
MLA Handbook (7th Edition):
Zeng, Yingfu. “Making Hybrid Systems Easier to Model, Simulate, and Visualize.” 2019. Web. 20 Jan 2021.
Vancouver:
Zeng Y. Making Hybrid Systems Easier to Model, Simulate, and Visualize. [Internet] [Doctoral dissertation]. Rice University; 2019. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/105397.
Council of Science Editors:
Zeng Y. Making Hybrid Systems Easier to Model, Simulate, and Visualize. [Doctoral Dissertation]. Rice University; 2019. Available from: http://hdl.handle.net/1911/105397
Rice University
5.
Fagan, Mike.
Soft typing: An approach to type checking for dynamically typed languages.
Degree: PhD, Engineering, 1991, Rice University
URL: http://hdl.handle.net/1911/16439
► In an effort to avoid improper use of program functions, modern programming languages employ some kind of preventative type system. These type systems can be…
(more)
▼ In an effort to avoid improper use of program functions, modern programming languages employ some kind of preventative type system. These type systems can be classified as either static or dynamic. Static type systems detect "ill-typed" program phrases at compile-time, whereas dynamic type systems detect "ill-typed" phrases at run-time.
Static typing systems have two important advantages over dynamically typed systems: First, they provide important feedback to the programmer by detecting a large class of program errors before execution. Second, they extract information that a compiler can exploit to produce more efficient code.
The price paid for these advantages, however, is a loss of expressiveness and modularity. It is easy to prove that a static type system for an "interesting" programming language necessarily excludes some "good" programs.
This paper focuses on the problem of designing programming systems that retain the all the expressiveness of dynamic typing, but still offer the early error detection and improved optimization opportunities of static typing. To that end, we introduce a concept called soft typing.
The key concept of soft typing is that a type checker need not reject programs containing statically "ill-typed" phrases. Instead, the soft type checker inserts explicit run-time checks. Thus, there are two issues to be addressed in the design of soft typing systems. First, the typing mechanism must provide reasonable feedback to programmers accustomed to dynamically typed-languages. Current static systems fail to satisfy the programmer's intuition about correctness on many programs. Second, a soft typing system must sensibly insert run-time checks (when necessary). This paper develops a type system and checking algorithms that are suitable for soft typing a significant class of programming languages.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Fagan, M. (1991). Soft typing: An approach to type checking for dynamically typed languages. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/16439
Chicago Manual of Style (16th Edition):
Fagan, Mike. “Soft typing: An approach to type checking for dynamically typed languages.” 1991. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/16439.
MLA Handbook (7th Edition):
Fagan, Mike. “Soft typing: An approach to type checking for dynamically typed languages.” 1991. Web. 20 Jan 2021.
Vancouver:
Fagan M. Soft typing: An approach to type checking for dynamically typed languages. [Internet] [Doctoral dissertation]. Rice University; 1991. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/16439.
Council of Science Editors:
Fagan M. Soft typing: An approach to type checking for dynamically typed languages. [Doctoral Dissertation]. Rice University; 1991. Available from: http://hdl.handle.net/1911/16439
Rice University
6.
Kanneganti, Ramarao.
Universal domains for sequential computation.
Degree: PhD, Engineering, 1995, Rice University
URL: http://hdl.handle.net/1911/16836
► Classical recursion theory asserts that all conventional programming languages are equally expressive because they can define all partial recursive functions over the natural numbers. However,…
(more)
▼ Classical recursion theory asserts that all conventional programming languages are equally expressive because they can define all partial recursive functions over the natural numbers. However, most real programming languages support some form of higher-order data such as potentially infinite streams, lazy trees, and functions. Since these objects do not have finite canonical representations, computations over these objects cannot be accurately modeled as ordinary computations over the natural numbers.
In my thesis, I develop a theory of higher order computability based on a new formulation of domain theory. This new formulation interprets elements of any data domain as lazy trees. Like classical domain theory, it provides a universal domain T and a universal language KL. A rich class of domains called observably sequential domains can be specified in T with functions definable in KL. Such an embedding of a data domain enables the operations on the domain to be defined in the universal language. Unlike embeddings in classical domain theory, embeddings in T retain enough computational information to separate terminating and non-terminating computations. An important practical consequence of this embedding is the fact that the definitions of program operations are effective, implying that denotational language definitions expressed in this framework are effective interpreters.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Kanneganti, R. (1995). Universal domains for sequential computation. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/16836
Chicago Manual of Style (16th Edition):
Kanneganti, Ramarao. “Universal domains for sequential computation.” 1995. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/16836.
MLA Handbook (7th Edition):
Kanneganti, Ramarao. “Universal domains for sequential computation.” 1995. Web. 20 Jan 2021.
Vancouver:
Kanneganti R. Universal domains for sequential computation. [Internet] [Doctoral dissertation]. Rice University; 1995. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/16836.
Council of Science Editors:
Kanneganti R. Universal domains for sequential computation. [Doctoral Dissertation]. Rice University; 1995. Available from: http://hdl.handle.net/1911/16836
Rice University
7.
Sasitorn, James.
Efficient implementation of first-class polymorphic methods in Java.
Degree: MS, Engineering, 2005, Rice University
URL: http://hdl.handle.net/1911/17822
► This thesis describes a new implementation architecture for polymorphic methods in Generic Java using the NEXTGEN compiler framework. The standard Generic Java (Java 1.5) compiler…
(more)
▼ This thesis describes a new implementation architecture for polymorphic methods in Generic Java using the NEXTGEN compiler framework. The standard Generic Java (Java 1.5) compiler erases generic types at compilation. This transformation prohibits type-dependent operations, limiting generic expressivity. Type erasure causes unchecked warnings at compilation, and unexpected behavior or exceptions at runtime. Alternative reflection-based implementations of Generic Java support type-dependent operations at the cost of significant execution overhead. In contrast, this work presents an efficient implementation of polymorphic methods using NEXTG EN. An extended NEXTGEN compiler generates snippet environment template classes to encode type-dependent operations for polymorphic methods. A customized class-loader generates specialized template instantiations on demand. This demand-driven code specialization provides an efficient mechanism to propagate runtime type information, while maintaining backwards compatibility with existing libraries and Java Virtual Machines. Benchmarks show runtime support for polymorphic methods in NEXTG EN outperforms reflection-based approaches, with runtime overhead comparable to erasure-based Generic Java.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Sasitorn, J. (2005). Efficient implementation of first-class polymorphic methods in Java. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/17822
Chicago Manual of Style (16th Edition):
Sasitorn, James. “Efficient implementation of first-class polymorphic methods in Java.” 2005. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/17822.
MLA Handbook (7th Edition):
Sasitorn, James. “Efficient implementation of first-class polymorphic methods in Java.” 2005. Web. 20 Jan 2021.
Vancouver:
Sasitorn J. Efficient implementation of first-class polymorphic methods in Java. [Internet] [Masters thesis]. Rice University; 2005. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/17822.
Council of Science Editors:
Sasitorn J. Efficient implementation of first-class polymorphic methods in Java. [Masters Thesis]. Rice University; 2005. Available from: http://hdl.handle.net/1911/17822
Rice University
8.
Jensen, Michael Dyrby.
Growing DrJava to cope with language extensions carried out in Java 5.0.
Degree: MS, Engineering, 2006, Rice University
URL: http://hdl.handle.net/1911/17884
► While Java continues to gain popularity in both industry and academia, few Java programming environments enable the user to directly interact with the code. Professional…
(more)
▼ While Java continues to gain popularity in both industry and academia, few Java programming environments enable the user to directly interact with the code. Professional environments require developers to use a command line interface to execute Java code. In contrast, our DrJava programming environment supports a read-eval-print-loop (REPL) incorporating a Java interpreter called DynamicJava – enabling developers to execute arbitrary fragments of Java code on-the-fly.
DynamicJava was developed at the
University of Nice, but development ceased in 2002 with DynamicJava supporting Java 1.3. In 2004, the Java language was extended in the Java 1.5 (renamed 5.0) release. To support Java 5.0 in DrJava, we were confronted with the task of extending DynamicJava to support the new language features.
This dissertation describes the new features in Java 5.0 – including generic types, autoboxing, variable arguments, static import, foreach, enumeration types and metadata – and explains how we extended the existing DynamicJava code base to support them.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Jensen, M. D. (2006). Growing DrJava to cope with language extensions carried out in Java 5.0. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/17884
Chicago Manual of Style (16th Edition):
Jensen, Michael Dyrby. “Growing DrJava to cope with language extensions carried out in Java 5.0.” 2006. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/17884.
MLA Handbook (7th Edition):
Jensen, Michael Dyrby. “Growing DrJava to cope with language extensions carried out in Java 5.0.” 2006. Web. 20 Jan 2021.
Vancouver:
Jensen MD. Growing DrJava to cope with language extensions carried out in Java 5.0. [Internet] [Masters thesis]. Rice University; 2006. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/17884.
Council of Science Editors:
Jensen MD. Growing DrJava to cope with language extensions carried out in Java 5.0. [Masters Thesis]. Rice University; 2006. Available from: http://hdl.handle.net/1911/17884
Rice University
9.
Reis, Charles S.
A pedagogic programming environment for Java that scales to production programming.
Degree: MS, Engineering, 2003, Rice University
URL: http://hdl.handle.net/1911/17642
► This thesis describes extensions to the DrJava development environment that make it suitable for production programming. DrJava is an effective tool for teaching introductory programming…
(more)
▼ This thesis describes extensions to the DrJava development environment that make it suitable for production programming. DrJava is an effective tool for teaching introductory programming skills in Java, and its simplicity is a desirable characteristic for projects of any size. To better support the development of large projects in DrJava, a carefully selected suite of features has been added to the environment. To facilitate interoperation with professional development environments, a plug-in supporting the DrJava interface has been written for the Eclipse environment. As a result of this work, DrJava has become an appropriate tool for teaching production programming skills in an academic environment, without sacrificing its original goals.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Reis, C. S. (2003). A pedagogic programming environment for Java that scales to production programming. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/17642
Chicago Manual of Style (16th Edition):
Reis, Charles S. “A pedagogic programming environment for Java that scales to production programming.” 2003. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/17642.
MLA Handbook (7th Edition):
Reis, Charles S. “A pedagogic programming environment for Java that scales to production programming.” 2003. Web. 20 Jan 2021.
Vancouver:
Reis CS. A pedagogic programming environment for Java that scales to production programming. [Internet] [Masters thesis]. Rice University; 2003. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/17642.
Council of Science Editors:
Reis CS. A pedagogic programming environment for Java that scales to production programming. [Masters Thesis]. Rice University; 2003. Available from: http://hdl.handle.net/1911/17642
Rice University
10.
Allen, Eric Ethan.
Efficient implementation of run-time generic types for Java.
Degree: MS, Engineering, 2002, Rice University
URL: http://hdl.handle.net/1911/17487
► One of the most significant limitations of the Java Programming Language is its lack of support for generic types. This thesis describes an efficient compiler…
(more)
▼ One of the most significant limitations of the Java Programming Language is its lack of support for generic types. This thesis describes an efficient compiler and run-time type system for NextGen, a compatible extension of Java that supports generic types, including type dependent operations. The NextGen compiler is implemented as an extension to the existing compiler for GJ, a limited generic extension of Java that does not support run-time generic types. Our implementation is homogeneous, with one major exception: Instantiations of generic classes are constructed on demand. This exception is necessary to support polymorphic recursion. The NextGen compiler generates templates for such instantiation classes and relies on a customized class loader to construct instantiations at run-time. A suite of benchmarks on the Java, GJ, and NextGen compilers shows that the additional code required to support run-time generic types has little or no overhead compared to ordinary Java and GJ.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Allen, E. E. (2002). Efficient implementation of run-time generic types for Java. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/17487
Chicago Manual of Style (16th Edition):
Allen, Eric Ethan. “Efficient implementation of run-time generic types for Java.” 2002. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/17487.
MLA Handbook (7th Edition):
Allen, Eric Ethan. “Efficient implementation of run-time generic types for Java.” 2002. Web. 20 Jan 2021.
Vancouver:
Allen EE. Efficient implementation of run-time generic types for Java. [Internet] [Masters thesis]. Rice University; 2002. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/17487.
Council of Science Editors:
Allen EE. Efficient implementation of run-time generic types for Java. [Masters Thesis]. Rice University; 2002. Available from: http://hdl.handle.net/1911/17487
Rice University
11.
Hsia, James I.
Adding support for language levels to DrJava.
Degree: MS, Engineering, 2005, Rice University
URL: http://hdl.handle.net/1911/17858
► This thesis describes the design and implementation of language levels, a pedagogic tool that helps students progressively learn object-oriented programming concepts in discrete stages. While…
(more)
▼ This thesis describes the design and implementation of language levels, a pedagogic tool that helps students progressively learn object-oriented programming concepts in discrete stages. While Java is widely used in academia, its complex syntax and large array of constructs are difficult for beginning students to learn. The language levels facility supports a hierarchy of progressively sophisticated subsets of the language. This progression minimizes the clerical burden involved in learning to write Java programs and reinforces the specific abstractions taught at each stage of
Rice introductory programming curriculum. In addition, the hierarchy of language levels reduces code clutter by automatically generating routine methods.
This language levels facility has been implemented as an extension of DrJava, a pedagogic programming environment for Java developed at
Rice University. We anticipate that this extension will enable more students to learn Java and master the principles of object-oriented programming.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Hsia, J. I. (2005). Adding support for language levels to DrJava. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/17858
Chicago Manual of Style (16th Edition):
Hsia, James I. “Adding support for language levels to DrJava.” 2005. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/17858.
MLA Handbook (7th Edition):
Hsia, James I. “Adding support for language levels to DrJava.” 2005. Web. 20 Jan 2021.
Vancouver:
Hsia JI. Adding support for language levels to DrJava. [Internet] [Masters thesis]. Rice University; 2005. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/17858.
Council of Science Editors:
Hsia JI. Adding support for language levels to DrJava. [Masters Thesis]. Rice University; 2005. Available from: http://hdl.handle.net/1911/17858
Rice University
12.
Smith, Daniel.
Designing type inference for typed object-oriented languages.
Degree: PhD, Engineering, 2010, Rice University
URL: http://hdl.handle.net/1911/62026
► Type-checked object-oriented languages have typically been designed with extremely simple type systems. However, there has recently been intense interest in extending such languages with more…
(more)
▼ Type-checked object-oriented languages have typically been designed with extremely simple type systems. However, there has recently been intense interest in extending such languages with more sophisticated types and subtyping relationships. JAVA and C# are mainstream languages that have been successfully extended with generic classes and methods; SCALA, FORTRESS, and X10 are new languages that adopt more advanced typing features, such as arrows, tuples, unions, intersections, dependent types, and existentials.
Presently, the type inference performed by these languages is unstable and evolving. This thesis explores problems arising in the design of a type inference specification for such languages.
We first present a formal description of subtyping in the context of a variety of advanced typing features. We then demonstrate how our formal subtyping algorithm can be easily re-expressed to produce a type inference algorithm, and observe that this algorithm is general enough to address a variety of important type-checking problems.
Finally, we apply this theory to a case study of the JAVA language's type system. We express JAVA'S types and inference algorithm in terms of our formal theory and note a variety of opportunities for improvement. We then describe the results of applying an improved type inference implementation to a selection of existing JAVA code, noting that, without introducing significant backwards-incompatibility problems for these programs, we've managed to significantly reduce the need for annotated method invocations.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science; Applied sciences
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Smith, D. (2010). Designing type inference for typed object-oriented languages. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/62026
Chicago Manual of Style (16th Edition):
Smith, Daniel. “Designing type inference for typed object-oriented languages.” 2010. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/62026.
MLA Handbook (7th Edition):
Smith, Daniel. “Designing type inference for typed object-oriented languages.” 2010. Web. 20 Jan 2021.
Vancouver:
Smith D. Designing type inference for typed object-oriented languages. [Internet] [Doctoral dissertation]. Rice University; 2010. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/62026.
Council of Science Editors:
Smith D. Designing type inference for typed object-oriented languages. [Doctoral Dissertation]. Rice University; 2010. Available from: http://hdl.handle.net/1911/62026
Rice University
13.
Smith, Daniel.
Completing the Java type system.
Degree: MS, Engineering, 2008, Rice University
URL: http://hdl.handle.net/1911/103594
► The recent introduction of type variables and wildcards to the Java language, while greatly enriching the expressivity of the type system, comes with prohibitions against…
(more)
▼ The recent introduction of type variables and wildcards to the Java language, while greatly enriching the expressivity of the type system, comes with prohibitions against a variety of natural and useful expressions. Principal among these is the declaration of type variables with lower (" super ") bounds, naturally motivated by the support for such bounds on wildcards. We describe two variations on the Java type system that enhance the current language specification with support for these features. These variations must address the inference of method type arguments, and in so doing improve the inference algorithm so that it is both sound and complete. The first, simpler variation makes use of union types ; the second more closely matches the current Java type system and formalizes its notion of "infinite types," as produced by static analysis.
Advisors/Committee Members: Cartwright, Robert (advisor).
Subjects/Keywords: Computer science; Applied sciences
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Smith, D. (2008). Completing the Java type system. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/103594
Chicago Manual of Style (16th Edition):
Smith, Daniel. “Completing the Java type system.” 2008. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/103594.
MLA Handbook (7th Edition):
Smith, Daniel. “Completing the Java type system.” 2008. Web. 20 Jan 2021.
Vancouver:
Smith D. Completing the Java type system. [Internet] [Masters thesis]. Rice University; 2008. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/103594.
Council of Science Editors:
Smith D. Completing the Java type system. [Masters Thesis]. Rice University; 2008. Available from: http://hdl.handle.net/1911/103594
Rice University
14.
Lu, Dennis Iee.
Dr. C#: A pedagogic IDE for C# featuring a read-eval-print-loop.
Degree: MS, Engineering, 2003, Rice University
URL: http://hdl.handle.net/1911/17606
► As the primary programming language of the Microsoft .NET platform, C# will play a significant role in software development for the foreseeable future. As the…
(more)
▼ As the primary programming language of the Microsoft .NET platform, C# will play a significant role in software development for the foreseeable future. As the language rapidly gains popularity in industry, tools made for C# development focus on the professional programmer, while leaving the beginning computer science student behind.
To address this problem, we introduce Dr. C#, a simple lightweight development environment with an integrated, interactive Read-Eval-Print-Loop (REPL). Dr. C# helps flatten the learning curve of both the environment and the language, enabling students to quickly learn key elements of the language and focus more easily on concepts. Dr. C# thus serves not only as a learning tool for beginner students but also as a teaching tool for instructors. The editor is based on an open source IDE called SharpDevelop. This thesis describes the implementation of Dr. C# focusing primarily on building the REPL and integrating with SharpDevelop.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Lu, D. I. (2003). Dr. C#: A pedagogic IDE for C# featuring a read-eval-print-loop. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/17606
Chicago Manual of Style (16th Edition):
Lu, Dennis Iee. “Dr. C#: A pedagogic IDE for C# featuring a read-eval-print-loop.” 2003. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/17606.
MLA Handbook (7th Edition):
Lu, Dennis Iee. “Dr. C#: A pedagogic IDE for C# featuring a read-eval-print-loop.” 2003. Web. 20 Jan 2021.
Vancouver:
Lu DI. Dr. C#: A pedagogic IDE for C# featuring a read-eval-print-loop. [Internet] [Masters thesis]. Rice University; 2003. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/17606.
Council of Science Editors:
Lu DI. Dr. C#: A pedagogic IDE for C# featuring a read-eval-print-loop. [Masters Thesis]. Rice University; 2003. Available from: http://hdl.handle.net/1911/17606
Rice University
15.
Sasitorn, James.
Component NextGen: A sound and expressive component framework for Java.
Degree: PhD, Engineering, 2007, Rice University
URL: http://hdl.handle.net/1911/20646
► Java has transformed mainstream software development by supporting clean object-oriented design, comprehensive static type checking, safe program execution, and an unprecedented degree of portability. Despite…
(more)
▼ Java has transformed mainstream software development by supporting clean object-oriented design, comprehensive static type checking, safe program execution, and an unprecedented degree of portability. Despite these significant achievements, the Java language has been handicapped as a vehicle for writing large applications by the absence of a component system for decomposing applications into independent units with statically checked interfaces.
Developing a general component system for an object-oriented language, such as Java, is a challenging design problem because inheritance across component boundaries can cause accidental method overrides. In addition, mutually recursive references across components are common in object-oriented programs – an issue that has proven troublesome in the context of component systems for functional and procedural languages.
This thesis discusses how a component framework can be constructed for a nominally typed object-oriented language supporting first-class generic types simply by adding appropriate annotations and syntactic sugar. The fundamental semantic building blocks for constructing, type-checking and manipulating components are provided by the underlying first-class generic type system. To demonstrate the simplicity and utility of this approach we have designed and implemented an extension of Java called Component N EXTGEN (CGEN). CGEN, which is based on the Sun Java 5.0 javac compiler, is backwards compatible with existing Java binary code and generates code that can be executed on current Java Virtual Machines.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Sasitorn, J. (2007). Component NextGen: A sound and expressive component framework for Java. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/20646
Chicago Manual of Style (16th Edition):
Sasitorn, James. “Component NextGen: A sound and expressive component framework for Java.” 2007. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/20646.
MLA Handbook (7th Edition):
Sasitorn, James. “Component NextGen: A sound and expressive component framework for Java.” 2007. Web. 20 Jan 2021.
Vancouver:
Sasitorn J. Component NextGen: A sound and expressive component framework for Java. [Internet] [Doctoral dissertation]. Rice University; 2007. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/20646.
Council of Science Editors:
Sasitorn J. Component NextGen: A sound and expressive component framework for Java. [Doctoral Dissertation]. Rice University; 2007. Available from: http://hdl.handle.net/1911/20646
Rice University
16.
Allen, Eric Ethan.
A first-class approach to genericity.
Degree: PhD, Engineering, 2003, Rice University
URL: http://hdl.handle.net/1911/18503
► This thesis describes how to add first-class generic types – including mixins – to strongly-typed object-oriented languages with nominal subtyping such as Java and C#. A generic…
(more)
▼ This thesis describes how to add first-class generic types – including mixins – to strongly-typed object-oriented languages with nominal subtyping such as Java and C#. A generic type system is "first-class" if generic types can appear in any context where conventional types can appear. In this context, a mixin is simply a generic class that extends one of its type parameters, e.g., a class C<T> that extends T. Although mixins of this form are widely used in C++ (via templates), they are clumsy and error-prone because C++ treats mixins as syntactic abbreviations (macros), forcing each mixin instantiation to be separately compiled and type-checked. The abstraction embodied in a mixin is never separately analyzed.
Our formulation of mixins using first-class genericity accommodates sound local (class-by-class) type checking. A mixin can be fully type-checked given symbol tables for each of the classes that it directly references – the same context in which Java performs incremental class compilation. To our knowledge, no previous formal analysis of first-class genericity in languages with nominal type systems has been conducted, which is surprising because nominal type systems have become predominant in mainstream object-oriented programming languages.
What makes our treatment of first-class genericity particularly interesting and important is the fact that it can be added to the existing Java language without any change to the underlying Java Virtual Machine. Moreover, the extension is backward compatible with legacy Java source and class files. Although our discussion of implementation issues focuses on Java, the same implementation techniques could be applied to other object-oriented languages such as C# or Eiffel that support incremental compilation, dynamic class loading, and a static type system with nominal subtyping.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Allen, E. E. (2003). A first-class approach to genericity. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/18503
Chicago Manual of Style (16th Edition):
Allen, Eric Ethan. “A first-class approach to genericity.” 2003. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/18503.
MLA Handbook (7th Edition):
Allen, Eric Ethan. “A first-class approach to genericity.” 2003. Web. 20 Jan 2021.
Vancouver:
Allen EE. A first-class approach to genericity. [Internet] [Doctoral dissertation]. Rice University; 2003. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/18503.
Council of Science Editors:
Allen EE. A first-class approach to genericity. [Doctoral Dissertation]. Rice University; 2003. Available from: http://hdl.handle.net/1911/18503
Rice University
17.
Stoler, Brian Richard.
A framework for building pedagogic Java programming environments.
Degree: MS, Engineering, 2002, Rice University
URL: http://hdl.handle.net/1911/17550
► Java has become the dominant language for teaching introductory computer science at both the high school and college levels. Yet Java's development tools and syntax…
(more)
▼ Java has become the dominant language for teaching introductory computer science at both the high school and college levels. Yet Java's development tools and syntax often distract beginning students from the programming concepts being taught. To combat this problem, we have implemented DrJava, a pedagogic programming environment, and devised a sequence of language levels for Java, which partition the language into pieces that can be more easily taught at one time.
DrJava is a lightweight, yet powerful, Java development environment suitable both for beginners and more advanced developers. The environment provides a simple interface based on a "read-eval-print loop" that enables a programmer to develop, test, and debug Java programs interactively and incrementally. DrJava is freely available under an open source license.
This thesis describes DrJava and an implementation framework and conceptual design for language levels in Java.
Advisors/Committee Members: Cartwright, Robert S. (advisor).
Subjects/Keywords: Technological education; Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Stoler, B. R. (2002). A framework for building pedagogic Java programming environments. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/17550
Chicago Manual of Style (16th Edition):
Stoler, Brian Richard. “A framework for building pedagogic Java programming environments.” 2002. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/17550.
MLA Handbook (7th Edition):
Stoler, Brian Richard. “A framework for building pedagogic Java programming environments.” 2002. Web. 20 Jan 2021.
Vancouver:
Stoler BR. A framework for building pedagogic Java programming environments. [Internet] [Masters thesis]. Rice University; 2002. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/17550.
Council of Science Editors:
Stoler BR. A framework for building pedagogic Java programming environments. [Masters Thesis]. Rice University; 2002. Available from: http://hdl.handle.net/1911/17550
18.
Imam, Shams.
Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models.
Degree: MS, Engineering, 2013, Rice University
URL: http://hdl.handle.net/1911/71662
► This study presents a hybrid concurrent programming model combining the previously developed Fork-Join model (FJM) and Actor model (AM). With the advent of multi-core computers,…
(more)
▼ This study presents a hybrid concurrent programming model combining the previously developed Fork-Join model (FJM) and Actor model (AM). With the advent of multi-core computers, there is a renewed interest in programming models that reduce the burden of reasoning about and writing efficient concurrent programs. The proposed hybrid model shows how the divide-and-conquer approach of the FJM and the no-shared mutable state and event-driven philosophy of the AM can be combined to solve certain classes of problems more efficiently and productively than either of the aforementioned models individually. The hybrid model adds actor creation and coordination
to into the FJM, while also enabling parallelization within actors. This study uses the Habanero-Java and Scala programming languages as the base for the FJM and AM respectively, and provides an implementation of the hybrid model as an extension of the Scala language called Habanero-Scala. The hybrid model adds to the foundations of parallel programs, and to the tools available for the programmer to aid in productivity and performance while developing parallel software.
Advisors/Committee Members: Sarkar, Vivek (advisor), Cartwright, Robert S. (committee member), Chaudhuri, Swarat (committee member).
Subjects/Keywords: Parallel programming; Actor model; Fork-join model; Async-finish model; Habanero-Scala
…Framework [23], OpenMP 3.0 [28] etc. At Rice University, we have
our own… …Habanero-C [30].
The Habanero Multicore Software Research Group at Rice University has… …Research Group at Rice University [29]. HJ supports AsyncFinish Model (AFM)…
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Imam, S. (2013). Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/71662
Chicago Manual of Style (16th Edition):
Imam, Shams. “Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models.” 2013. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/71662.
MLA Handbook (7th Edition):
Imam, Shams. “Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models.” 2013. Web. 20 Jan 2021.
Vancouver:
Imam S. Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models. [Internet] [Masters thesis]. Rice University; 2013. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/71662.
Council of Science Editors:
Imam S. Habanero-Scala: A Hybrid Programming model integrating Fork/Join and Actor models. [Masters Thesis]. Rice University; 2013. Available from: http://hdl.handle.net/1911/71662
19.
Inoue, Jun.
Reasoning About Multi-stage Programs.
Degree: PhD, Engineering, 2013, Rice University
URL: http://hdl.handle.net/1911/71663
► Multi-stage programming (MSP) is a style of writing program generators – programs which generate programs – supported by special annotations that direct construction, combination, and execution of…
(more)
▼ Multi-stage programming (MSP) is a style of writing program
generators – programs which generate programs – supported by special
annotations that direct construction, combination, and execution of
object programs. Various researchers have shown MSP to be effective
in writing efficient programs without sacrificing genericity.
However, correctness proofs of such programs have so far received
limited attention, and approaches and challenges for that task have
been largely unexplored. In this thesis, I establish formal
equational properties of the multi-stage lambda calculus and related
proof techniques, as well as results that delineate the intricacies
of multi-stage languages that one must be aware of.
In particular, I settle three basic questions that naturally arise
when verifying multi-stage functional programs. Firstly, can adding
staging MSP to a language compromise the interchangeability of terms
that held in the original language? Unfortunately it can, and more
care is needed to reason about terms with free variables. Secondly,
staging annotations, as the term ``annotations'' suggests, are often
thought to be orthogonal to the behavior of a program, but when is
this formally guaranteed to be the case? I give termination
conditions that characterize when this guarantee holds. Finally, do
multi-stage languages satisfy extensional facts, for example that
functions agreeing on all arguments are equivalent? I develop a
sound and complete notion of applicative bisimulation, which can
establish not only extensionality but, in principle, any other valid
program equivalence as well. These results improve our general
understanding of staging and enable us to prove the correctness of
complicated multi-stage programs.
Advisors/Committee Members: Cartwright, Robert S. (advisor), Taha, Walid (committee member), Sarkar, Vivek (committee member), O'Malley, Marcia K. (committee member).
Subjects/Keywords: Multi-stage languages; Verification; Equational theory; Bisimulation; Annotation erasure
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Inoue, J. (2013). Reasoning About Multi-stage Programs. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/71663
Chicago Manual of Style (16th Edition):
Inoue, Jun. “Reasoning About Multi-stage Programs.” 2013. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/71663.
MLA Handbook (7th Edition):
Inoue, Jun. “Reasoning About Multi-stage Programs.” 2013. Web. 20 Jan 2021.
Vancouver:
Inoue J. Reasoning About Multi-stage Programs. [Internet] [Doctoral dissertation]. Rice University; 2013. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/71663.
Council of Science Editors:
Inoue J. Reasoning About Multi-stage Programs. [Doctoral Dissertation]. Rice University; 2013. Available from: http://hdl.handle.net/1911/71663
Rice University
20.
Parsons, Rebecca Jane.
Semantic program dependence graphs.
Degree: PhD, Engineering, 1992, Rice University
URL: http://hdl.handle.net/1911/16541
► Semantic program dependence graphs, or semantic pdgs, are an attractive intermediate program representation for use in advanced optimizing and parallelizing compilers. The semantic pdg, which…
(more)
▼ Semantic program dependence graphs, or semantic pdgs, are an attractive intermediate program representation for use in advanced optimizing and parallelizing compilers. The semantic pdg, which is based on the program dependence graph, has a compositional semantics that provides an elegant characterization of the types of dependences that arise in imperative programming languages. In addition, the semantic pdg has a simple operational semantics which serves as the basis of an equational calculus reasoning about semantic pdgs. Finally, the algorithms for creating the semantic pdg are efficient enough to allow the use of this program representation in actual compilers.
The semantic pdg is the result of a study, using denotational semantics, into the notions of data and control dependence in imperative programming languages. Semantic pdgs include a new component, the valve node, which ensures the data flow character of the semantic pdg, even in the presence of conditional assignments, and provides the control information necessary to perform many important program optimizations. The valve node is a natural result of the derivation step that addresses the data dependence relation. The semantic pdg utilizes the new concept of a partial array to allow for optimizations of array accesses while maintaining the mathematical elegance of the data flow semantics of the pdg.
The semantic pdg is not only an elegant representation from a mathematical perspective, but it is also a useful representation from a practical perspective. This structure is particularly well-suited for use in optimizing and parallelizing compilers since it explicates the important relationships among the different statements in a program. We have developed a program representation that is powerful enough to represent the behavior of a program, that provides the information needed to optimize the program, and that has a precise mathematical description. The development of the semantic pdg reconciles the often contradictory requirements of mathematical elegance and practicality.
Advisors/Committee Members: Felleisen, Matthias (advisor), Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Parsons, R. J. (1992). Semantic program dependence graphs. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/16541
Chicago Manual of Style (16th Edition):
Parsons, Rebecca Jane. “Semantic program dependence graphs.” 1992. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/16541.
MLA Handbook (7th Edition):
Parsons, Rebecca Jane. “Semantic program dependence graphs.” 1992. Web. 20 Jan 2021.
Vancouver:
Parsons RJ. Semantic program dependence graphs. [Internet] [Doctoral dissertation]. Rice University; 1992. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/16541.
Council of Science Editors:
Parsons RJ. Semantic program dependence graphs. [Doctoral Dissertation]. Rice University; 1992. Available from: http://hdl.handle.net/1911/16541
Rice University
21.
Wright, Andrew Kevin.
Practical soft typing.
Degree: PhD, Engineering, 1995, Rice University
URL: http://hdl.handle.net/1911/16900
► Soft typing is an approach to type checking for dynamically typed languages. Like a static type checker, a soft type checker infers syntactic types for…
(more)
▼ Soft typing is an approach to type checking for dynamically typed languages. Like a static type checker, a soft type checker infers syntactic types for identifiers and expressions. But rather than reject programs containing untypable fragments, a soft type checker inserts explicit run-time checks to ensure safe execution.
Soft typing was first introduced in an idealized form by
Cartwright and Fagan. This thesis investigates the issues involved in designing a practical soft type system. A soft type system for a purely functional, call-by-value language is developed by extending the Hindley-Milner polymorphic type system with recursive types and limited forms of union types. The extension adapts Remy's encoding of record types with subtyping to union types. The encoding yields more compact types and permits more efficient type inference than
Cartwright and Fagan's early technique. Correctness proofs are developed by employing a new syntactic approach to type soundness. As the type inference algorithm yields complex internal types that are difficult for programmers to understand, a more familiar language of presentation types is developed along with translations between internal and presentation types. To address realistic programming languages like Scheme, the soft type system is extended to incorporate assignment, continuations, pattern matching, data definition, records, modules, explicit type annotations, and macros. Imperative features like assignment and continuations are typed by a new, simple method of combining imperative features with Hindley-Milner polymorphism.
The thesis shows soft typing to be practical by illustrating a prototype soft type system for Scheme. Type information determined by the prototype is sufficiently precise to provide useful diagnostic aid to programmers and to effectively minimize run-time checking. The type checker typically eliminates 90% of the run-time checks that are necessary for safe execution with dynamic typing. This reduction in run-time checking leads to significant speedup for some bench marks. Through several examples, the thesis shows how prototypes, developed using a purely semantic understanding of types as sets of values, can be transformed into robust maintainable, and efficient programs by rewriting them to accommodate better syntactic type assignment.
Advisors/Committee Members: Cartwright, Robert S. (advisor), Felleisen, Matthias (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Wright, A. K. (1995). Practical soft typing. (Doctoral Dissertation). Rice University. Retrieved from http://hdl.handle.net/1911/16900
Chicago Manual of Style (16th Edition):
Wright, Andrew Kevin. “Practical soft typing.” 1995. Doctoral Dissertation, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/16900.
MLA Handbook (7th Edition):
Wright, Andrew Kevin. “Practical soft typing.” 1995. Web. 20 Jan 2021.
Vancouver:
Wright AK. Practical soft typing. [Internet] [Doctoral dissertation]. Rice University; 1995. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/16900.
Council of Science Editors:
Wright AK. Practical soft typing. [Doctoral Dissertation]. Rice University; 1995. Available from: http://hdl.handle.net/1911/16900
Rice University
22.
Graunke, Paul Thorsen.
Programming the Web with high-level programming languages.
Degree: MS, Engineering, 2001, Rice University
URL: http://hdl.handle.net/1911/17425
► Concepts from high-level languages can greatly simplify the design and implementation of CGI programs. This dissertation develops two systems for implementing these programs. The first…
(more)
▼ Concepts from high-level languages can greatly simplify the design and implementation of CGI programs. This dissertation develops two systems for implementing these programs.
The first technique* relies on a custom Web server that dynamically loads CGI programs using the operating system-style services of MrEd, an extension of Scheme. The server implements programming mechanisms using continuations that allow the CGI program to interact with the user in a natural manner.
The second technique relies on program transformations from functional language compilation.† It allows the use of standard servers and alleviates most of the memory consumption on the server.
In my thesis I discuss the advantages and disadvantages of each approach. I conclude with suggestions for further investigations into this topic.
*The first technique previously appeared at the European Symposium on Programming, 2001 A.D., in a paper with the same title as this dissertation, coauthored with Shriram Krishnamurthi, Steve van der Hoeven, and Matthias Felleisen. †The compilation based technique was submitted to the International Conference on Functional Programming in a paper titled, "How to Design and Generate CGI Programs: Applying Functional Compiler Techniques to the Real World," coauthored with
Robert Bruce Findler, Shriram Krishnamurthi, and Matthias Felleisen.
Advisors/Committee Members: Felleisen, Matthias (advisor), Cartwright, Robert S. (advisor).
Subjects/Keywords: Computer science
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Graunke, P. T. (2001). Programming the Web with high-level programming languages. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/17425
Chicago Manual of Style (16th Edition):
Graunke, Paul Thorsen. “Programming the Web with high-level programming languages.” 2001. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/17425.
MLA Handbook (7th Edition):
Graunke, Paul Thorsen. “Programming the Web with high-level programming languages.” 2001. Web. 20 Jan 2021.
Vancouver:
Graunke PT. Programming the Web with high-level programming languages. [Internet] [Masters thesis]. Rice University; 2001. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/17425.
Council of Science Editors:
Graunke PT. Programming the Web with high-level programming languages. [Masters Thesis]. Rice University; 2001. Available from: http://hdl.handle.net/1911/17425
Rice University
23.
Kelley, Robert S. (b. 1831).
A preliminary evaluation of a manually controlled computer.
Degree: MA, Engineering, 1982, Rice University
URL: http://hdl.handle.net/1911/104669
► We have developed a novel display control for interactive computer systems. This permits users to make a single displayed file scroll up or down by…
(more)
▼ We have developed a novel display control for interactive computer systems. This permits users to make a single displayed file scroll up or down by moving a hand control in the appropriate direction. The rate at which the system scrolls depends on the degree of control displacement; consequently it is more flexible than conventional keyboard systems. We further developed a two file version which displays files side by side, with their motion controlled in a similar manner. We evaluated the system's effect on task performance in two experiments, one dealing with computer programming, the other with word processing. The results are generally favorable. Subjects reported that they liked the controls and would find them useful in their work. The controls significantly reduced the number of keystrokes required in both experiments; in addition, in the first experiment, subjects who used the controls the most were significantly faster in completing the tasks.
Advisors/Committee Members: Tuggle, Francis D. (advisor), Cartwright, Robert S.;Gorry, G. Anthony (committee member).
Record Details
Similar Records
Cite
Share »
Record Details
Similar Records
Cite
« Share
❌
APA ·
Chicago ·
MLA ·
Vancouver ·
CSE |
Export
to Zotero / EndNote / Reference
Manager
APA (6th Edition):
Kelley, R. S. (. 1. (1982). A preliminary evaluation of a manually controlled computer. (Masters Thesis). Rice University. Retrieved from http://hdl.handle.net/1911/104669
Chicago Manual of Style (16th Edition):
Kelley, Robert S (b 1831). “A preliminary evaluation of a manually controlled computer.” 1982. Masters Thesis, Rice University. Accessed January 20, 2021.
http://hdl.handle.net/1911/104669.
MLA Handbook (7th Edition):
Kelley, Robert S (b 1831). “A preliminary evaluation of a manually controlled computer.” 1982. Web. 20 Jan 2021.
Vancouver:
Kelley RS(1. A preliminary evaluation of a manually controlled computer. [Internet] [Masters thesis]. Rice University; 1982. [cited 2021 Jan 20].
Available from: http://hdl.handle.net/1911/104669.
Council of Science Editors:
Kelley RS(1. A preliminary evaluation of a manually controlled computer. [Masters Thesis]. Rice University; 1982. Available from: http://hdl.handle.net/1911/104669
. 
Open Access Theses and Dissertations
